@fluentui/react-utilities 0.0.0-nightly-20240607-1142.1 → 0.0.0-nightly-20240610-0407.1

package/CHANGELOG.md

@@ -1,19 +1,19 @@
 # Change Log - @fluentui/react-utilities
 
-This log was last generated on Fri, 07 Jun 2024 12:00:01 GMT and should not be manually modified.
+This log was last generated on Mon, 10 Jun 2024 04:26:06 GMT and should not be manually modified.
 
 <!-- Start content -->
 
-## [0.0.0-nightly-20240607-1142.1](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v0.0.0-nightly-20240607-1142.1)
+## [0.0.0-nightly-20240610-0407.1](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v0.0.0-nightly-20240610-0407.1)
 
-Fri, 07 Jun 2024 12:00:01 GMT 
-[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.18.10..@fluentui/react-utilities_v0.0.0-nightly-20240607-1142.1)
+Mon, 10 Jun 2024 04:26:06 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.18.10..@fluentui/react-utilities_v0.0.0-nightly-20240610-0407.1)
 
 ### Changes
 
 - Release nightly v9 ([commit](https://github.com/microsoft/fluentui/commit/not available) by fluentui-internal@service.microsoft.com)
-- Bump @fluentui/keyboard-keys to v0.0.0-nightly-20240607-1142.1 ([commit](https://github.com/microsoft/fluentui/commit/40da052540066d9cb9e19ae1127d52eeccb7a699) by beachball)
-- Bump @fluentui/react-shared-contexts to v0.0.0-nightly-20240607-1142.1 ([commit](https://github.com/microsoft/fluentui/commit/40da052540066d9cb9e19ae1127d52eeccb7a699) by beachball)
+- Bump @fluentui/keyboard-keys to v0.0.0-nightly-20240610-0407.1 ([commit](https://github.com/microsoft/fluentui/commit/8c240a734142a59db285f343c2aa30b4b790a761) by beachball)
+- Bump @fluentui/react-shared-contexts to v0.0.0-nightly-20240610-0407.1 ([commit](https://github.com/microsoft/fluentui/commit/8c240a734142a59db285f343c2aa30b4b790a761) by beachball)
 
 ## [9.18.10](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.18.10)
 

package/dist/index.d.ts

@@ -9,7 +9,7 @@ import * as React_2 from 'react';
  * * `elementType` - the base element type of a slot, defaults to `'div'`
  * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.
  */
-declare function always<Props extends SlotPropsDataType>(value: Props | SlotShorthandValue | undefined, options: SlotOptions<Props>): SlotComponentType<Props>;
+declare function always<Props extends UnknownSlotProps>(value: Props | SlotShorthandValue | undefined, options: SlotOptions<Props>): SlotComponentType<Props>;
 
 /**
  * @internal
@@ -65,47 +65,23 @@ export declare function canUseDOM(): boolean;
  */
 export declare const clamp: (value: number, min: number, max: number) => number;
 
-/**
- * @internal
- * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
- */
-declare interface ComponentClass<P = {}, S = React_2.ComponentState> extends React_2.StaticLifecycle<P, S> {
-    new (props: P): React_2.Component<P, S>;
-}
-
 /**
  * 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.
  */
-export declare type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> = Omit<Slots, Primary & 'root'> & PropsWithoutRef<WithoutSlotRenderFunction<ExtractSlotProps<Slots[Primary]>>>;
+export declare type ComponentProps<Slots extends SlotPropsRecord, Primary extends keyof Slots = 'root'> = Omit<Slots, Primary & 'root'> & PropsWithoutRef<ExtractSlotProps<Slots[Primary]>>;
 
 /**
  * Defines the State object of a component given its slots.
  */
 export declare type ComponentState<Slots extends SlotPropsRecord> = {
-    /**
-     * @deprecated
-     * The base element type for each slot.
-     * This property is deprecated and will be removed in a future version.
-     * The slot base element type is declared through `slot.*(slotShorthand, {elementType: ElementType})` instead.
-     */
     components: {
-        [Key in keyof Slots]-?: React_2.ElementType;
+        [Key in keyof Slots]-?: React_2.ComponentType<ExtractSlotProps<Slots[Key]>> | (ExtractSlotProps<Slots[Key]> extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
     };
 } & {
-    [Key in keyof Slots]: ReplaceNullWithUndefined<WithoutSlotRenderFunction<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>>;
+    [Key in keyof Slots]: ReplaceNullWithUndefined<Exclude<Slots[Key], SlotShorthandValue | (Key extends 'root' ? null : never)>>;
 };
 
-/**
- * @internal
- * With react 18, our `children` type starts leaking everywhere and that causes conflicts on component declaration, specially in the `propTypes` property of
- * both `ComponentClass` and `FunctionComponent`.
- *
- * This type substitutes `React.ComponentType` only keeping the function signature, it omits `propTypes`, `displayName` and other properties that are not
- * required for the inference.
- */
-declare type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
-
 /**
  * @internal
  * @param compare - comparison function for items
@@ -194,32 +170,8 @@ export declare type FluentTriggerComponent = {
 
 /**
  * Return type for `React.forwardRef`, including inference of the proper typing for the ref.
- *
- * Note: {@link React.RefAttributes} is {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/69756 | leaking string references} into forwardRef components, forwardRef component do not support string refs.
  */
-export declare type ForwardRefComponent<Props> = FunctionComponent<Props & React_2.RefAttributes<InferredElementRefType<Props>>>;
-
-/**
- * @internal
- *
- * On types/react 18 there are two types being delivered,
- * they rely on the typescript version to decide which will be consumed {@link https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b59dc3ac1e2770fbd6cdbb90ba52abe04c168196/types/react/package.json#L10}
- *
- * If TS is higher than 5.0 then the `FunctionComponent` will be returning ReactNode (which we don't support)
- * If TS is below or equal to 5.0 then the `FunctionComponent` will be returning ReactElement | null (which we support)
- *
- * Since it's not possible to have a single type that works for both cases
- * (as ReactNode is more specific, and this will break while evaluating functions),
- * we need to create our own `FunctionComponent` type
- * that will work for both cases.
- *
- * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
- */
-declare interface FunctionComponent<P> {
-    (props: P): any;
-    defaultProps?: Partial<P>;
-    displayName?: string;
-}
+export declare type ForwardRefComponent<Props> = React_2.ForwardRefExoticComponent<Props & React_2.RefAttributes<InferredElementRefType<Props>>>;
 
 /**
  * Returns an object with clientX, clientY for TouchOrMouseEvent.
@@ -236,7 +188,7 @@ export declare function getEventClientCoords(event: TouchOrMouseEvent): {
  *
  * Equivalent to {@link getNativeElementProps}, but more type-safe.
  */
-export declare const getIntrinsicElementProps: <Props extends SlotPropsDataType, ExcludedPropKeys extends Extract<keyof Props, string> = never>(tagName: NonNullable<Props["as"]>, props: Props & React_2.RefAttributes<InferredElementRefType<Props>>, excludedPropNames?: ExcludedPropKeys[] | undefined) => DistributiveOmit<Props, ExcludedPropKeys | Exclude<keyof Props, "slot" | "style" | "title" | "as" | "children" | "className" | "defaultChecked" | "defaultValue" | "suppressContentEditableWarning" | "suppressHydrationWarning" | "accessKey" | "contentEditable" | "contextMenu" | "dir" | "draggable" | "hidden" | "id" | "lang" | "placeholder" | "spellCheck" | "tabIndex" | "translate" | "radioGroup" | "role" | "about" | "datatype" | "inlist" | "prefix" | "property" | "resource" | "typeof" | "vocab" | "autoCapitalize" | "autoCorrect" | "autoSave" | "color" | "itemProp" | "itemScope" | "itemType" | "itemID" | "itemRef" | "results" | "security" | "unselectable" | "inputMode" | "is" | "aria-activedescendant" | "aria-atomic" | "aria-autocomplete" | "aria-busy" | "aria-checked" | "aria-colcount" | "aria-colindex" | "aria-colspan" | "aria-controls" | "aria-current" | "aria-describedby" | "aria-details" | "aria-disabled" | "aria-dropeffect" | "aria-errormessage" | "aria-expanded" | "aria-flowto" | "aria-grabbed" | "aria-haspopup" | "aria-hidden" | "aria-invalid" | "aria-keyshortcuts" | "aria-label" | "aria-labelledby" | "aria-level" | "aria-live" | "aria-modal" | "aria-multiline" | "aria-multiselectable" | "aria-orientation" | "aria-owns" | "aria-placeholder" | "aria-posinset" | "aria-pressed" | "aria-readonly" | "aria-relevant" | "aria-required" | "aria-roledescription" | "aria-rowcount" | "aria-rowindex" | "aria-rowspan" | "aria-selected" | "aria-setsize" | "aria-sort" | "aria-valuemax" | "aria-valuemin" | "aria-valuenow" | "aria-valuetext" | "dangerouslySetInnerHTML" | "onCopy" | "onCopyCapture" | "onCut" | "onCutCapture" | "onPaste" | "onPasteCapture" | "onCompositionEnd" | "onCompositionEndCapture" | "onCompositionStart" | "onCompositionStartCapture" | "onCompositionUpdate" | "onCompositionUpdateCapture" | "onFocus" | "onFocusCapture" | "onBlur" | "onBlurCapture" | "onChange" | "onChangeCapture" | "onBeforeInput" | "onBeforeInputCapture" | "onInput" | "onInputCapture" | "onReset" | "onResetCapture" | "onSubmit" | "onSubmitCapture" | "onInvalid" | "onInvalidCapture" | "onLoad" | "onLoadCapture" | "onError" | "onErrorCapture" | "onKeyDown" | "onKeyDownCapture" | "onKeyPress" | "onKeyPressCapture" | "onKeyUp" | "onKeyUpCapture" | "onAbort" | "onAbortCapture" | "onCanPlay" | "onCanPlayCapture" | "onCanPlayThrough" | "onCanPlayThroughCapture" | "onDurationChange" | "onDurationChangeCapture" | "onEmptied" | "onEmptiedCapture" | "onEncrypted" | "onEncryptedCapture" | "onEnded" | "onEndedCapture" | "onLoadedData" | "onLoadedDataCapture" | "onLoadedMetadata" | "onLoadedMetadataCapture" | "onLoadStart" | "onLoadStartCapture" | "onPause" | "onPauseCapture" | "onPlay" | "onPlayCapture" | "onPlaying" | "onPlayingCapture" | "onProgress" | "onProgressCapture" | "onRateChange" | "onRateChangeCapture" | "onSeeked" | "onSeekedCapture" | "onSeeking" | "onSeekingCapture" | "onStalled" | "onStalledCapture" | "onSuspend" | "onSuspendCapture" | "onTimeUpdate" | "onTimeUpdateCapture" | "onVolumeChange" | "onVolumeChangeCapture" | "onWaiting" | "onWaitingCapture" | "onAuxClick" | "onAuxClickCapture" | "onClick" | "onClickCapture" | "onContextMenu" | "onContextMenuCapture" | "onDoubleClick" | "onDoubleClickCapture" | "onDrag" | "onDragCapture" | "onDragEnd" | "onDragEndCapture" | "onDragEnter" | "onDragEnterCapture" | "onDragExit" | "onDragExitCapture" | "onDragLeave" | "onDragLeaveCapture" | "onDragOver" | "onDragOverCapture" | "onDragStart" | "onDragStartCapture" | "onDrop" | "onDropCapture" | "onMouseDown" | "onMouseDownCapture" | "onMouseEnter" | "onMouseLeave" | "onMouseMove" | "onMouseMoveCapture" | "onMouseOut" | "onMouseOutCapture" | "onMouseOver" | "onMouseOverCapture" | "onMouseUp" | "onMouseUpCapture" | "onSelect" | "onSelectCapture" | "onTouchCancel" | "onTouchCancelCapture" | "onTouchEnd" | "onTouchEndCapture" | "onTouchMove" | "onTouchMoveCapture" | "onTouchStart" | "onTouchStartCapture" | "onPointerDown" | "onPointerDownCapture" | "onPointerMove" | "onPointerMoveCapture" | "onPointerUp" | "onPointerUpCapture" | "onPointerCancel" | "onPointerCancelCapture" | "onPointerEnter" | "onPointerEnterCapture" | "onPointerLeave" | "onPointerLeaveCapture" | "onPointerOver" | "onPointerOverCapture" | "onPointerOut" | "onPointerOutCapture" | "onGotPointerCapture" | "onGotPointerCaptureCapture" | "onLostPointerCapture" | "onLostPointerCaptureCapture" | "onScroll" | "onScrollCapture" | "onWheel" | "onWheelCapture" | "onAnimationStart" | "onAnimationStartCapture" | "onAnimationEnd" | "onAnimationEndCapture" | "onAnimationIteration" | "onAnimationIterationCapture" | "onTransitionEnd" | "onTransitionEndCapture">>;
+export declare const getIntrinsicElementProps: <Props extends UnknownSlotProps, ExcludedPropKeys extends Extract<keyof Props, string> = never>(tagName: NonNullable<Props["as"]>, props: Props & React_2.RefAttributes<InferredElementRefType<Props>>, excludedPropNames?: ExcludedPropKeys[] | undefined) => DistributiveOmit<Props, ExcludedPropKeys | Exclude<keyof Props, "as" | keyof HTMLAttributes>>;
 
 /**
  * Given an element tagname and user props, filters the props to only allowed props for the given
@@ -312,7 +264,7 @@ export declare const getRTLSafeKey: (key: string, dir: 'ltr' | 'rtl') => string;
  * @param state - State including slot definitions
  * @returns An object containing the `slots` map and `slotProps` map.
  */
-export declare function getSlots<R extends SlotPropsRecord>(state: unknown): {
+export declare function getSlots<R extends SlotPropsRecord>(state: ComponentState<R>): {
     slots: Slots<R>;
     slotProps: ObjectSlotProps<R>;
 };
@@ -327,7 +279,7 @@ export declare function getSlots<R extends SlotPropsRecord>(state: unknown): {
  *
  * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */
-export declare function getSlotsNext<R extends SlotPropsRecord>(state: unknown): {
+export declare function getSlotsNext<R extends SlotPropsRecord>(state: ComponentState<R>): {
     slots: Slots<R>;
     slotProps: ObjectSlotProps<R>;
 };
@@ -358,6 +310,8 @@ export declare function getTriggerChild<TriggerChildProps>(children: TriggerProp
     ref?: React_2.Ref<any>;
 }) | null;
 
+declare type HTMLAttributes = React_2.HTMLAttributes<any>;
+
 /**
  * @internal
  */
@@ -451,7 +405,7 @@ export declare function isMouseEvent(event: TouchOrMouseEvent): event is MouseEv
  * })
  * ```
  */
-export declare function isResolvedShorthand<Shorthand extends Slot<SlotPropsDataType>>(shorthand?: Shorthand): shorthand is ExtractSlotProps<Shorthand>;
+export declare function isResolvedShorthand<Shorthand extends Slot<UnknownSlotProps>>(shorthand?: Shorthand): shorthand is ExtractSlotProps<Shorthand>;
 
 /**
  * Evaluates to true if the given type contains exactly one string, or false if it is a union of strings.
@@ -558,7 +512,7 @@ export declare type OnSelectionChangeData = {
  * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content
  * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`
  */
-declare function optional<Props extends SlotPropsDataType>(value: Props | SlotShorthandValue | undefined | null, options: {
+declare function optional<Props extends UnknownSlotProps>(value: Props | SlotShorthandValue | undefined | null, options: {
     renderByDefault?: boolean;
 } & SlotOptions<Props>): SlotComponentType<Props> | undefined;
 
@@ -599,18 +553,6 @@ declare type PropsWithoutChildren<P> = 'children' extends keyof P ? Distributive
  */
 declare type PropsWithoutRef<P> = 'ref' extends keyof P ? DistributiveOmit<P, 'ref'> : P;
 
-/**
- * @internal
- *
- * on types/react 18 ReactNode becomes a more strict type, which is not compatible with our current implementation. to avoid any issues we are creating our own ReactNode type which allows anything.
- *
- * This type should only be used for inference purposes, and should never be exposed.
- *
- * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
- *
- */
-declare type ReactNode = any;
-
 export declare type ReactTouchOrMouseEvent = React_2.MouseEvent | React_2.TouchEvent;
 
 /**
@@ -637,23 +579,23 @@ export declare function resetIdsForTests(): void;
  * @param value - the base shorthand props
  * @param options - options to resolve shorthand props
  *
- * @deprecated use slot.always, slot.optional, slot.resolveShorthand combined with assertSlots instead
+ * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */
-export declare const resolveShorthand: ResolveShorthandFunction<SlotPropsDataType>;
+export declare const resolveShorthand: ResolveShorthandFunction<UnknownSlotProps>;
 
 /**
  * Helper function that converts a slot shorthand or properties to a slot properties object
  * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object
  * @param value - the value of the slot, it can be a slot shorthand or a slot properties object
  */
-declare function resolveShorthand_2<Props extends SlotPropsDataType | null | undefined>(value: Props | SlotShorthandValue): Props;
+declare function resolveShorthand_2<Props extends UnknownSlotProps | null | undefined>(value: Props | SlotShorthandValue): Props;
 
 /**
  * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */
-export declare type ResolveShorthandFunction<Props extends SlotPropsDataType = SlotPropsDataType> = {
-    <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): WithoutSlotRenderFunction<P>;
-    <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>): WithoutSlotRenderFunction<P> | undefined;
+export declare type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {
+    <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;
+    <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>): P | undefined;
 };
 
 /**
@@ -728,11 +670,13 @@ export declare function setVirtualParent(child: Node, parent?: Node): void;
  * 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 | ComponentType<any> | SlotPropsDataType, 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<IntrinsicElementProps<Type>> : Type extends ComponentType<infer Props> ? Props extends SlotPropsDataType ? Props : WithSlotRenderFunction<Props> : Type> | (AlternateAs extends unknown ? {
-    as: AlternateAs;
-} & WithSlotRenderFunction<IntrinsicElementProps<AlternateAs>> : never) | null : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';
+} & WithSlotRenderFunction<IntrinsicElementProps<Type>> : Type extends React_2.ComponentType<infer Props> ? WithSlotRenderFunction<Props> : Type> | {
+    [As in AlternateAs]: {
+        as: As;
+    } & WithSlotRenderFunction<IntrinsicElementProps<As>>;
+}[AlternateAs] | null : 'Error: First parameter to Slot must not be not a union of types. See documentation of Slot type.';
 
 declare namespace slot {
     export {
@@ -771,9 +715,11 @@ declare type SlotComponents<Slots extends SlotPropsRecord> = {
  * A definition of a slot, as a component, very similar to how a React component is declared,
  * but with some additional metadata that is used to determine how to render the slot.
  */
-export declare type SlotComponentType<Props extends SlotPropsDataType> = WithoutSlotRenderFunction<Props> & FunctionComponent<{
-    children?: ReactNode;
-}> & {
+export declare type SlotComponentType<Props extends UnknownSlotProps> = Props & {
+    /**
+     * **NOTE**: Slot components are not callable.
+     */
+    (props: React_2.PropsWithChildren<{}>): React_2.ReactElement | null;
     /**
      * @internal
      */
@@ -781,25 +727,12 @@ export declare type SlotComponentType<Props extends SlotPropsDataType> = Without
     /**
      * @internal
      */
-    [SLOT_ELEMENT_TYPE_SYMBOL]: ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+    [SLOT_ELEMENT_TYPE_SYMBOL]: React_2.ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
 };
 
-export declare type SlotOptions<Props extends SlotPropsDataType> = {
+export declare type SlotOptions<Props extends UnknownSlotProps> = {
     elementType: React_2.ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
-    defaultProps?: Partial<Props & {
-        ref?: React_2.Ref<InferredElementRefType<Props>>;
-    }>;
-};
-
-/**
- * @internal
- *
- * This should ONLY be used in type templates as in `extends SlotPropsDataType`;
- * it shouldn't be used as a component's Slot props type.
- */
-declare type SlotPropsDataType = {
-    as?: keyof JSX.IntrinsicElements;
-    children?: ReactNode;
+    defaultProps?: Partial<Props>;
 };
 
 /**
@@ -808,9 +741,9 @@ declare type SlotPropsDataType = {
  * This should ONLY be used in type templates as in `extends SlotPropsRecord`;
  * it shouldn't be used as a component's Slots type.
  */
-export declare type SlotPropsRecord = Record<string, SlotPropsDataType | SlotShorthandValue | null | undefined>;
+export declare type SlotPropsRecord = Record<string, UnknownSlotProps | SlotShorthandValue | null | undefined>;
 
-export declare type SlotRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'as'>) => ReactNode;
+export declare type SlotRenderFunction<Props> = (Component: React_2.ElementType<Props>, props: Omit<Props, 'as'>) => React_2.ReactNode;
 
 /**
  * @deprecated - use slot.always or slot.optional combined with assertSlots instead
@@ -822,7 +755,7 @@ export declare type Slots<S extends SlotPropsRecord> = {
 /**
  * The shorthand value of a slot allows specifying its child
  */
-export declare type SlotShorthandValue = React_2.ReactElement | string | number | Iterable<ReactNode> | React_2.ReactPortal;
+export declare type SlotShorthandValue = React_2.ReactChild | React_2.ReactNode[] | React_2.ReactPortal;
 
 /**
  * When using SSR with Fluent UI, applications must be wrapped in an SSRProvider. This ensures that auto generated ids
@@ -852,7 +785,6 @@ export declare type TriggerProps<TriggerChildProps = unknown> = {
 export declare type UnionToIntersection<U> = (U extends unknown ? (x: U) => U : never) extends (x: infer I) => U ? I : never;
 
 /**
- * @deprecated - SlotPropsDataType instead
  * Matches any slot props type.
  *
  * This should ONLY be used in type templates as in `extends UnknownSlotProps`;
@@ -1058,19 +990,13 @@ export declare function useSelection(params: SelectionHookParams): readonly [Set
 export declare function useTimeout(): readonly [(fn: () => void, delay?: number | undefined) => number, () => void];
 
 /**
- * @internal
- */
-declare type WithoutSlotRenderFunction<Props> = Props extends unknown ? 'children' extends keyof Props ? Omit<Props, 'children'> & {
-    children?: Exclude<Props['children'], Function>;
-} : Props : never;
-
-/**
- * @internal
  * 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.
  */
-declare type WithSlotRenderFunction<Props> = Omit<Props, 'children'> & {
-    children?: ('children' extends keyof Props ? Props['children'] : never) | SlotRenderFunction<Props>;
+declare type WithSlotRenderFunction<Props> = Props & {
+    children?: (Props extends {
+        children?: unknown;
+    } ? Props['children'] : never) | SlotRenderFunction<Props>;
 };
 
 /**

package/lib/compose/assertSlots.js

@@ -26,7 +26,6 @@ import * as slot from './slot';
    * as we're verifying static properties that will not change between environments
    */ if (process.env.NODE_ENV !== 'production') {
         const typedState = state;
-        // eslint-disable-next-line deprecation/deprecation
         for (const slotName of Object.keys(typedState.components)){
             const slotElement = typedState[slotName];
             if (slotElement === undefined) {
@@ -37,7 +36,6 @@ import * as slot from './slot';
             // FIXME: this slot will still fail to support child render function scenario
             if (!isSlot(slotElement)) {
                 typedState[slotName] = slot.always(slotElement, {
-                    // eslint-disable-next-line deprecation/deprecation
                     elementType: typedState.components[slotName]
                 });
                 // eslint-disable-next-line no-console
@@ -48,9 +46,7 @@ Be sure to create slots properly by using "slot.always" or "slot.optional".`);
                 // This means a slot is being declared by using resolveShorthand on the state hook,
                 // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type
                 const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;
-                // eslint-disable-next-line deprecation/deprecation
                 if (elementType !== typedState.components[slotName]) {
-                    // eslint-disable-next-line deprecation/deprecation
                     slotElement[SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName];
                     // eslint-disable-next-line no-console
                     console.warn(`@fluentui/react-utilities [${assertSlots.name}]:

package/lib/compose/assertSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["assertSlots.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport { ComponentState, ExtractSlotProps, SlotComponentType, SlotPropsRecord } from './types';\nimport * as slot from './slot';\n\ntype SlotComponents<Slots extends SlotPropsRecord> = {\n  [K in keyof Slots]: SlotComponentType<ExtractSlotProps<Slots[K]>>;\n};\n\n/**\n * @internal\n * Assertion method to ensure state slots properties are properly declared.\n * A properly declared slot must be declared by using the `slot` method.\n *\n * @example\n * ```tsx\n * export const renderInput_unstable = (state: InputState) => {\n    assertSlots<InputSlots>(state);\n    return (\n      <state.root>\n        {state.contentBefore && <state.contentBefore />}\n        <state.input />\n        {state.contentAfter && <state.contentAfter />}\n      </state.root>\n    );\n  };\n * ```\n */\nexport function assertSlots<Slots extends SlotPropsRecord>(state: unknown): asserts state is SlotComponents<Slots> {\n  /**\n   * This verification is not necessary in production\n   * as we're verifying static properties that will not change between environments\n   */\n  if (process.env.NODE_ENV !== 'production') {\n    const typedState = state as ComponentState<Slots>;\n    // eslint-disable-next-line deprecation/deprecation\n    for (const slotName of Object.keys(typedState.components)) {\n      const slotElement = typedState[slotName];\n      if (slotElement === undefined) {\n        continue;\n      }\n      // this means a slot is being declared without using, slot.always or slot.optional or even resolveShorthand on the state hook,\n      // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n      // FIXME: this slot will still fail to support child render function scenario\n      if (!isSlot(slotElement)) {\n        typedState[slotName as keyof ComponentState<Slots>] = slot.always(slotElement, {\n          // eslint-disable-next-line deprecation/deprecation\n          elementType: typedState.components[slotName] as React.ComponentType<{}>,\n        }) as ComponentState<Slots>[keyof ComponentState<Slots>];\n        // eslint-disable-next-line no-console\n        console.warn(/** #__DE-INDENT__ */ `\n          @fluentui/react-utilities [${assertSlots.name}]:\n          \"state.${slotName}\" is not a slot!\n          Be sure to create slots properly by using \"slot.always\" or \"slot.optional\".\n        `);\n      } else {\n        // This means a slot is being declared by using resolveShorthand on the state hook,\n        // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n        const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;\n        // eslint-disable-next-line deprecation/deprecation\n        if (elementType !== typedState.components[slotName]) {\n          // eslint-disable-next-line deprecation/deprecation\n          slotElement[SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName] as React.ComponentType<{}>;\n          // eslint-disable-next-line no-console\n          console.warn(/** #__DE-INDENT__ */ `\n            @fluentui/react-utilities [${assertSlots.name}]:\n            \"state.${slotName}\" element type differs from \"state.components.${slotName}\",\n            ${elementType} !== ${typedState.components[slotName] /* eslint-disable-line deprecation/deprecation */}.\n            Be sure to create slots properly by using \"slot.always\" or \"slot.optional\" with the correct elementType.\n          `);\n        }\n      }\n    }\n  }\n}\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","isSlot","slot","assertSlots","state","process","env","NODE_ENV","typedState","slotName","Object","keys","components","slotElement","undefined","always","elementType","console","warn","name"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,QAAQ,cAAc;AACvD,SAASC,MAAM,QAAQ,WAAW;AAElC,YAAYC,UAAU,SAAS;AAM/B;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,YAA2CC,KAAc;IACvE;;;GAGC,GACD,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAMC,aAAaJ;QACnB,mDAAmD;QACnD,KAAK,MAAMK,YAAYC,OAAOC,IAAI,CAACH,WAAWI,UAAU,EAAG;YACzD,MAAMC,cAAcL,UAAU,CAACC,SAAS;YACxC,IAAII,gBAAgBC,WAAW;gBAC7B;YACF;YACA,8HAA8H;YAC9H,4JAA4J;YAC5J,6EAA6E;YAC7E,IAAI,CAACb,OAAOY,cAAc;gBACxBL,UAAU,CAACC,SAAwC,GAAGP,KAAKa,MAAM,CAACF,aAAa;oBAC7E,mDAAmD;oBACnDG,aAAaR,WAAWI,UAAU,CAACH,SAAS;gBAC9C;gBACA,sCAAsC;gBACtCQ,QAAQC,IAAI,CAAuB,CAAC,2BACP,EAAEf,YAAYgB,IAAI,CAAC;OACvC,EAAEV,SAAS;2EAEpB,CAAC;YACH,OAAO;gBACL,mFAAmF;gBACnF,4JAA4J;gBAC5J,MAAM,EAAE,CAACT,yBAAyB,EAAEgB,WAAW,EAAE,GAAGH;gBACpD,mDAAmD;gBACnD,IAAIG,gBAAgBR,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACnD,mDAAmD;oBACnDI,WAAW,CAACb,yBAAyB,GAAGQ,WAAWI,UAAU,CAACH,SAAS;oBACvE,sCAAsC;oBACtCQ,QAAQC,IAAI,CAAuB,CAAC,2BACP,EAAEf,YAAYgB,IAAI,CAAC;OACvC,EAAEV,SAAS,8CAA8C,EAAEA,SAAS;AAC3E,EAAEO,YAAY,KAAK,EAAER,WAAWI,UAAU,CAACH,SAAS,CAAmD;wGAEzG,CAAC;gBACH;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["assertSlots.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport { ComponentState, ExtractSlotProps, SlotComponentType, SlotPropsRecord } from './types';\nimport * as slot from './slot';\n\ntype SlotComponents<Slots extends SlotPropsRecord> = {\n  [K in keyof Slots]: SlotComponentType<ExtractSlotProps<Slots[K]>>;\n};\n\n/**\n * @internal\n * Assertion method to ensure state slots properties are properly declared.\n * A properly declared slot must be declared by using the `slot` method.\n *\n * @example\n * ```tsx\n * export const renderInput_unstable = (state: InputState) => {\n    assertSlots<InputSlots>(state);\n    return (\n      <state.root>\n        {state.contentBefore && <state.contentBefore />}\n        <state.input />\n        {state.contentAfter && <state.contentAfter />}\n      </state.root>\n    );\n  };\n * ```\n */\nexport function assertSlots<Slots extends SlotPropsRecord>(state: unknown): asserts state is SlotComponents<Slots> {\n  /**\n   * This verification is not necessary in production\n   * as we're verifying static properties that will not change between environments\n   */\n  if (process.env.NODE_ENV !== 'production') {\n    const typedState = state as ComponentState<Slots>;\n    for (const slotName of Object.keys(typedState.components)) {\n      const slotElement = typedState[slotName];\n      if (slotElement === undefined) {\n        continue;\n      }\n      // this means a slot is being declared without using, slot.always or slot.optional or even resolveShorthand on the state hook,\n      // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n      // FIXME: this slot will still fail to support child render function scenario\n      if (!isSlot(slotElement)) {\n        typedState[slotName as keyof ComponentState<Slots>] = slot.always(slotElement, {\n          elementType: typedState.components[slotName] as React.ComponentType<{}>,\n        }) as ComponentState<Slots>[keyof ComponentState<Slots>];\n        // eslint-disable-next-line no-console\n        console.warn(/** #__DE-INDENT__ */ `\n          @fluentui/react-utilities [${assertSlots.name}]:\n          \"state.${slotName}\" is not a slot!\n          Be sure to create slots properly by using \"slot.always\" or \"slot.optional\".\n        `);\n      } else {\n        // This means a slot is being declared by using resolveShorthand on the state hook,\n        // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n        const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;\n        if (elementType !== typedState.components[slotName]) {\n          slotElement[SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName] as React.ComponentType<{}>;\n          // eslint-disable-next-line no-console\n          console.warn(/** #__DE-INDENT__ */ `\n            @fluentui/react-utilities [${assertSlots.name}]:\n            \"state.${slotName}\" element type differs from \"state.components.${slotName}\",\n            ${elementType} !== ${typedState.components[slotName]}.\n            Be sure to create slots properly by using \"slot.always\" or \"slot.optional\" with the correct elementType.\n          `);\n        }\n      }\n    }\n  }\n}\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","isSlot","slot","assertSlots","state","process","env","NODE_ENV","typedState","slotName","Object","keys","components","slotElement","undefined","always","elementType","console","warn","name"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,QAAQ,cAAc;AACvD,SAASC,MAAM,QAAQ,WAAW;AAElC,YAAYC,UAAU,SAAS;AAM/B;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,YAA2CC,KAAc;IACvE;;;GAGC,GACD,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAMC,aAAaJ;QACnB,KAAK,MAAMK,YAAYC,OAAOC,IAAI,CAACH,WAAWI,UAAU,EAAG;YACzD,MAAMC,cAAcL,UAAU,CAACC,SAAS;YACxC,IAAII,gBAAgBC,WAAW;gBAC7B;YACF;YACA,8HAA8H;YAC9H,4JAA4J;YAC5J,6EAA6E;YAC7E,IAAI,CAACb,OAAOY,cAAc;gBACxBL,UAAU,CAACC,SAAwC,GAAGP,KAAKa,MAAM,CAACF,aAAa;oBAC7EG,aAAaR,WAAWI,UAAU,CAACH,SAAS;gBAC9C;gBACA,sCAAsC;gBACtCQ,QAAQC,IAAI,CAAuB,CAAC,2BACP,EAAEf,YAAYgB,IAAI,CAAC;OACvC,EAAEV,SAAS;2EAEpB,CAAC;YACH,OAAO;gBACL,mFAAmF;gBACnF,4JAA4J;gBAC5J,MAAM,EAAE,CAACT,yBAAyB,EAAEgB,WAAW,EAAE,GAAGH;gBACpD,IAAIG,gBAAgBR,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACnDI,WAAW,CAACb,yBAAyB,GAAGQ,WAAWI,UAAU,CAACH,SAAS;oBACvE,sCAAsC;oBACtCQ,QAAQC,IAAI,CAAuB,CAAC,2BACP,EAAEf,YAAYgB,IAAI,CAAC;OACvC,EAAEV,SAAS,8CAA8C,EAAEA,SAAS;AAC3E,EAAEO,YAAY,KAAK,EAAER,WAAWI,UAAU,CAACH,SAAS,CAAC;wGAEvD,CAAC;gBACH;YACF;QACF;IACF;AACF"}

package/lib/compose/deprecated/getSlots.js

@@ -21,14 +21,12 @@ import { SLOT_RENDER_FUNCTION_SYMBOL } from '../constants';
  * @param state - State including slot definitions
  * @returns An object containing the `slots` map and `slotProps` map.
  */ export function getSlots(state) {
-    const typeState = state;
     // eslint-disable-next-line deprecation/deprecation
     const slots = {};
     const slotProps = {};
-    // eslint-disable-next-line deprecation/deprecation
-    const slotNames = Object.keys(typeState.components);
+    const slotNames = Object.keys(state.components);
     for (const slotName of slotNames){
-        const [slot, props] = getSlot(typeState, slotName);
+        const [slot, props] = getSlot(state, slotName);
         // eslint-disable-next-line deprecation/deprecation
         slots[slotName] = slot;
         slotProps[slotName] = props;
@@ -51,9 +49,7 @@ function getSlot(state, slotName) {
     // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)
     const { as: asProp, children, ...rest } = props;
     const renderFunction = isSlot(props) ? props[SLOT_RENDER_FUNCTION_SYMBOL] : undefined;
-    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation
-    // eslint-disable-next-line deprecation/deprecation
-    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
     if (renderFunction || typeof children === 'function') {
         const render = renderFunction || children;
         return [
@@ -64,7 +60,6 @@ function getSlot(state, slotName) {
         ];
     }
     const shouldOmitAsProp = typeof slot === 'string' && asProp;
-    // eslint-disable-next-line deprecation/deprecation
     const slotProps = shouldOmitAsProp ? omit(props, [
         'as'
     ]) : props;

package/lib/compose/deprecated/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getSlots.ts"],"sourcesContent":["import * as React from 'react';\nimport { omit } from '../../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnknownSlotProps,\n} from '../types';\nimport { isSlot } from '../isSlot';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from '../constants';\nimport { UnionToIntersection } from '../../utils/types';\n\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\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\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\n */\nexport type 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]> // Slot<'div', 'span'>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P // Slot<typeof Button>\n    : ExtractSlotProps<S[K]>; // Slot<ButtonProps>\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 * @deprecated use slot.always or slot.optional combined with assertSlots instead\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: unknown,\n): {\n  // eslint-disable-next-line deprecation/deprecation\n  slots: Slots<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  slotProps: ObjectSlotProps<R>;\n} {\n  const typeState = state as ComponentState<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  // eslint-disable-next-line deprecation/deprecation\n  const slotNames: (keyof R)[] = Object.keys(typeState.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(typeState, slotName);\n    // eslint-disable-next-line deprecation/deprecation\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line deprecation/deprecation\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  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  type NonUndefined<T> = T extends undefined ? never : T;\n  // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n  const { as: asProp, children, ...rest } = props as NonUndefined<typeof props>;\n\n  const renderFunction = isSlot(props) ? props[SLOT_RENDER_FUNCTION_SYMBOL] : undefined;\n\n  const slot = (\n    state.components?.[slotName] === undefined || // eslint-disable-line deprecation/deprecation\n    // eslint-disable-next-line deprecation/deprecation\n    typeof state.components[slotName] === 'string'\n      ? // eslint-disable-next-line deprecation/deprecation\n        asProp || state.components?.[slotName] || 'div'\n      : // eslint-disable-next-line deprecation/deprecation\n        state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  if (renderFunction || typeof children === 'function') {\n    const render = (renderFunction || children) as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      {\n        children: render(slot, rest as Omit<R[K], 'as'>),\n      } as unknown as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  // eslint-disable-next-line deprecation/deprecation\n  const slotProps = (shouldOmitAsProp ? omit(props, ['as']) : (props as UnknownSlotProps)) as R[K];\n  return [slot, slotProps];\n}\n"],"names":["React","omit","isSlot","SLOT_RENDER_FUNCTION_SYMBOL","getSlots","state","typeState","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","undefined","as","asProp","children","rest","renderFunction","render","Fragment","shouldOmitAsProp"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,IAAI,QAAQ,mBAAmB;AASxC,SAASC,MAAM,QAAQ,YAAY;AACnC,SAASC,2BAA2B,QAAQ,eAAe;AA4B3D;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,SACdC,KAAc;IAOd,MAAMC,YAAYD;IAClB,mDAAmD;IACnD,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,mDAAmD;IACnD,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,UAAUM,UAAU;IAC/D,KAAK,MAAMC,YAAYJ,UAAW;QAChC,MAAM,CAACK,MAAMC,MAAM,GAAGC,QAAQV,WAAWO;QACzC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,mDAAmD;IACnD,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE;AAEA,SAASQ,QACPX,KAAwB,EACxBQ,QAAW;QAeTR,mBAIcA;IAjBhB,MAAMU,QAAQV,KAAK,CAACQ,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC;YAAMA;SAAkB;IAClC;IAGA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAEC,QAAQ,EAAE,GAAGC,MAAM,GAAGN;IAE1C,MAAMO,iBAAiBpB,OAAOa,SAASA,KAAK,CAACZ,4BAA4B,GAAGc;IAE5E,MAAMH,OACJT,EAAAA,oBAAAA,MAAMO,UAAU,cAAhBP,wCAAAA,iBAAkB,CAACQ,SAAS,MAAKI,aAAa,8CAA8C;IAC5F,mDAAmD;IACnD,OAAOZ,MAAMO,UAAU,CAACC,SAAS,KAAK,WAElCM,YAAUd,qBAAAA,MAAMO,UAAU,cAAhBP,yCAAAA,kBAAkB,CAACQ,SAAS,KAAI,QAE1CR,MAAMO,UAAU,CAACC,SAAS;IAGhC,IAAIS,kBAAkB,OAAOF,aAAa,YAAY;QACpD,MAAMG,SAAUD,kBAAkBF;QAClC,OAAO;YACLpB,MAAMwB,QAAQ;YACd;gBACEJ,UAAUG,OAAOT,MAAMO;YACzB;SACD;IACH;IAEA,MAAMI,mBAAmB,OAAOX,SAAS,YAAYK;IACrD,mDAAmD;IACnD,MAAMX,YAAaiB,mBAAmBxB,KAAKc,OAAO;QAAC;KAAK,IAAKA;IAC7D,OAAO;QAACD;QAAMN;KAAU;AAC1B"}
+{"version":3,"sources":["getSlots.ts"],"sourcesContent":["import * as React from 'react';\nimport { omit } from '../../utils/omit';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnknownSlotProps,\n} from '../types';\nimport { isSlot } from '../isSlot';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from '../constants';\nimport { UnionToIntersection } from '../../utils/types';\n\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\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\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\n */\nexport type 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]> // Slot<'div', 'span'>\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? P // Slot<typeof Button>\n    : ExtractSlotProps<S[K]>; // Slot<ButtonProps>\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 * @deprecated use slot.always or slot.optional combined with assertSlots instead\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  // eslint-disable-next-line deprecation/deprecation\n  slots: Slots<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  slotProps: ObjectSlotProps<R>;\n} {\n  // eslint-disable-next-line deprecation/deprecation\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    // eslint-disable-next-line deprecation/deprecation\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line deprecation/deprecation\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  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  type NonUndefined<T> = T extends undefined ? never : T;\n  // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n  const { as: asProp, children, ...rest } = props as NonUndefined<typeof props>;\n\n  const renderFunction = isSlot(props) ? props[SLOT_RENDER_FUNCTION_SYMBOL] : undefined;\n\n  const slot = (\n    state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n      ? asProp || state.components?.[slotName] || 'div'\n      : state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  if (renderFunction || typeof children === 'function') {\n    const render = (renderFunction || children) as SlotRenderFunction<R[K]>;\n    return [\n      React.Fragment,\n      {\n        children: render(slot, rest as Omit<R[K], 'as'>),\n      } as unknown as R[K],\n    ];\n  }\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  const slotProps = (shouldOmitAsProp ? omit(props, ['as']) : (props as UnknownSlotProps)) as R[K];\n  return [slot, slotProps];\n}\n"],"names":["React","omit","isSlot","SLOT_RENDER_FUNCTION_SYMBOL","getSlots","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","undefined","as","asProp","children","rest","renderFunction","render","Fragment","shouldOmitAsProp"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,IAAI,QAAQ,mBAAmB;AASxC,SAASC,MAAM,QAAQ,YAAY;AACnC,SAASC,2BAA2B,QAAQ,eAAe;AA4B3D;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,SACdC,KAAwB;IAOxB,mDAAmD;IACnD,MAAMC,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,MAAMM,UAAU;IAC3D,KAAK,MAAMC,YAAYJ,UAAW;QAChC,MAAM,CAACK,MAAMC,MAAM,GAAGC,QAAQV,OAAOO;QACrC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,mDAAmD;IACnD,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE;AAEA,SAASQ,QACPV,KAAwB,EACxBO,QAAW;QAeTP,mBACcA;IAdhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC;YAAMA;SAAkB;IAClC;IAGA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAEC,QAAQ,EAAE,GAAGC,MAAM,GAAGN;IAE1C,MAAMO,iBAAiBnB,OAAOY,SAASA,KAAK,CAACX,4BAA4B,GAAGa;IAE5E,MAAMH,OACJR,EAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,wCAAAA,iBAAkB,CAACO,SAAS,MAAKI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFM,YAAUb,qBAAAA,MAAMM,UAAU,cAAhBN,yCAAAA,kBAAkB,CAACO,SAAS,KAAI,QAC1CP,MAAMM,UAAU,CAACC,SAAS;IAGhC,IAAIS,kBAAkB,OAAOF,aAAa,YAAY;QACpD,MAAMG,SAAUD,kBAAkBF;QAClC,OAAO;YACLnB,MAAMuB,QAAQ;YACd;gBACEJ,UAAUG,OAAOT,MAAMO;YACzB;SACD;IACH;IAEA,MAAMI,mBAAmB,OAAOX,SAAS,YAAYK;IACrD,MAAMX,YAAaiB,mBAAmBvB,KAAKa,OAAO;QAAC;KAAK,IAAKA;IAC7D,OAAO;QAACD;QAAMN;KAAU;AAC1B"}

package/lib/compose/deprecated/getSlotsNext.js

@@ -9,15 +9,13 @@ import * as React from 'react';
  *
  * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */ export function getSlotsNext(state) {
-    const typedState = state;
     // eslint-disable-next-line deprecation/deprecation
     const slots = {};
     const slotProps = {};
-    // eslint-disable-next-line deprecation/deprecation
-    const slotNames = Object.keys(typedState.components);
+    const slotNames = Object.keys(state.components);
     for (const slotName of slotNames){
         // eslint-disable-next-line deprecation/deprecation
-        const [slot, props] = getSlotNext(typedState, slotName);
+        const [slot, props] = getSlotNext(state, slotName);
         // eslint-disable-next-line deprecation/deprecation
         slots[slotName] = slot;
         slotProps[slotName] = props;
@@ -41,11 +39,8 @@ import * as React from 'react';
     }
     // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)
     const { as: asProp, ...propsWithoutAs } = props;
-    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation
-    // eslint-disable-next-line deprecation/deprecation
-    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
     const shouldOmitAsProp = typeof slot === 'string' && asProp;
-    // eslint-disable-next-line deprecation/deprecation
     const slotProps = shouldOmitAsProp ? propsWithoutAs : props;
     return [
         slot,

package/lib/compose/deprecated/getSlotsNext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getSlotsNext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentState, SlotPropsRecord, UnknownSlotProps } from '../types';\nimport { ObjectSlotProps, Slots } from './getSlots';\n\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n *\n * @internal\n * This is an internal temporary method, this method will cease to exist eventually!\n *\n * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️\n *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nexport function getSlotsNext<R extends SlotPropsRecord>(\n  state: unknown,\n): {\n  // eslint-disable-next-line deprecation/deprecation\n  slots: Slots<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  slotProps: ObjectSlotProps<R>;\n} {\n  const typedState = state as ComponentState<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  // eslint-disable-next-line deprecation/deprecation\n  const slotNames: (keyof R)[] = Object.keys(typedState.components);\n  for (const slotName of slotNames) {\n    // eslint-disable-next-line deprecation/deprecation\n    const [slot, props] = getSlotNext(typedState, slotName);\n    // eslint-disable-next-line deprecation/deprecation\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line deprecation/deprecation\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nfunction getSlotNext<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  type NonUndefined<T> = T extends undefined ? never : T;\n  // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n  const { as: asProp, ...propsWithoutAs } = props as NonUndefined<typeof props>;\n\n  const slot = (\n    state.components?.[slotName] === undefined || // eslint-disable-line deprecation/deprecation\n    // eslint-disable-next-line deprecation/deprecation\n    typeof state.components[slotName] === 'string'\n      ? // eslint-disable-next-line deprecation/deprecation\n        asProp || state.components?.[slotName] || 'div'\n      : // eslint-disable-next-line deprecation/deprecation\n        state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  // eslint-disable-next-line deprecation/deprecation\n  const slotProps: UnknownSlotProps = shouldOmitAsProp ? propsWithoutAs : props;\n\n  return [slot, slotProps as R[K]];\n}\n"],"names":["React","getSlotsNext","state","typedState","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAI/B;;;;;;;;;CASC,GACD,OAAO,SAASC,aACdC,KAAc;IAOd,MAAMC,aAAaD;IACnB,mDAAmD;IACnD,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,mDAAmD;IACnD,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,WAAWM,UAAU;IAChE,KAAK,MAAMC,YAAYJ,UAAW;QAChC,mDAAmD;QACnD,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,YAAYO;QAC9C,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,mDAAmD;IACnD,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE;AAEA;;CAEC,GACD,SAASQ,YACPX,KAAwB,EACxBQ,QAAW;QAaTR,mBAIcA;IAfhB,MAAMU,QAAQV,KAAK,CAACQ,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC;YAAMA;SAAkB;IAClC;IAGA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAE,GAAGC,gBAAgB,GAAGL;IAE1C,MAAMD,OACJT,EAAAA,oBAAAA,MAAMO,UAAU,cAAhBP,wCAAAA,iBAAkB,CAACQ,SAAS,MAAKI,aAAa,8CAA8C;IAC5F,mDAAmD;IACnD,OAAOZ,MAAMO,UAAU,CAACC,SAAS,KAAK,WAElCM,YAAUd,qBAAAA,MAAMO,UAAU,cAAhBP,yCAAAA,kBAAkB,CAACQ,SAAS,KAAI,QAE1CR,MAAMO,UAAU,CAACC,SAAS;IAGhC,MAAMQ,mBAAmB,OAAOP,SAAS,YAAYK;IACrD,mDAAmD;IACnD,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL;IAExE,OAAO;QAACD;QAAMN;KAAkB;AAClC"}
+{"version":3,"sources":["getSlotsNext.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ComponentState, SlotPropsRecord, UnknownSlotProps } from '../types';\nimport { ObjectSlotProps, Slots } from './getSlots';\n\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n *\n * @internal\n * This is an internal temporary method, this method will cease to exist eventually!\n *\n * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️\n *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nexport function getSlotsNext<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  // eslint-disable-next-line deprecation/deprecation\n  slots: Slots<R>;\n  // eslint-disable-next-line deprecation/deprecation\n  slotProps: ObjectSlotProps<R>;\n} {\n  // eslint-disable-next-line deprecation/deprecation\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    // eslint-disable-next-line deprecation/deprecation\n    const [slot, props] = getSlotNext(state, slotName);\n    // eslint-disable-next-line deprecation/deprecation\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line deprecation/deprecation\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nfunction getSlotNext<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  type NonUndefined<T> = T extends undefined ? never : T;\n  // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n  const { as: asProp, ...propsWithoutAs } = props as NonUndefined<typeof props>;\n\n  const slot = (\n    state.components?.[slotName] === undefined || typeof state.components[slotName] === 'string'\n      ? asProp || state.components?.[slotName] || 'div'\n      : state.components[slotName]\n  ) as React.ElementType<R[K]>;\n\n  const shouldOmitAsProp = typeof slot === 'string' && asProp;\n  const slotProps: UnknownSlotProps = shouldOmitAsProp ? propsWithoutAs : props;\n\n  return [slot, slotProps as R[K]];\n}\n"],"names":["React","getSlotsNext","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAI/B;;;;;;;;;CASC,GACD,OAAO,SAASC,aACdC,KAAwB;IAOxB,mDAAmD;IACnD,MAAMC,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,MAAMM,UAAU;IAC3D,KAAK,MAAMC,YAAYJ,UAAW;QAChC,mDAAmD;QACnD,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,OAAOO;QACzC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,mDAAmD;IACnD,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE;AAEA;;CAEC,GACD,SAASQ,YACPV,KAAwB,EACxBO,QAAW;QAaTP,mBACcA;IAZhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC;YAAMA;SAAkB;IAClC;IAGA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAE,GAAGC,gBAAgB,GAAGL;IAE1C,MAAMD,OACJR,EAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,wCAAAA,iBAAkB,CAACO,SAAS,MAAKI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFM,YAAUb,qBAAAA,MAAMM,UAAU,cAAhBN,yCAAAA,kBAAkB,CAACO,SAAS,KAAI,QAC1CP,MAAMM,UAAU,CAACC,SAAS;IAGhC,MAAMQ,mBAAmB,OAAOP,SAAS,YAAYK;IACrD,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL;IAExE,OAAO;QAACD;QAAMN;KAAkB;AAClC"}

package/lib/compose/deprecated/resolveShorthand.js

@@ -6,7 +6,7 @@ import * as slot from '../slot';
  * @param value - the base shorthand props
  * @param options - options to resolve shorthand props
  *
- * @deprecated use slot.always, slot.optional, slot.resolveShorthand combined with assertSlots instead
+ * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */ // eslint-disable-next-line deprecation/deprecation
 export const resolveShorthand = (value, options)=>slot.optional(value, {
         ...options,

package/lib/compose/deprecated/resolveShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["resolveShorthand.ts"],"sourcesContent":["import * as slot from '../slot';\nimport type { SlotPropsDataType, SlotShorthandValue, WithoutSlotRenderFunction } from '../types';\n\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\n */\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true\n  ? { required: true; defaultProps?: Props }\n  : { required?: Required; defaultProps?: Props };\n\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nexport type ResolveShorthandFunction<Props extends SlotPropsDataType = SlotPropsDataType> = {\n  <P extends Props>(\n    value: P | SlotShorthandValue | undefined,\n    // eslint-disable-next-line deprecation/deprecation\n    options: ResolveShorthandOptions<P, true>,\n  ): WithoutSlotRenderFunction<P>;\n  // eslint-disable-next-line deprecation/deprecation\n  <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | WithoutSlotRenderFunction<P>\n    | undefined;\n};\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 *\n * @deprecated use slot.always, slot.optional, slot.resolveShorthand combined with assertSlots instead\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const resolveShorthand: ResolveShorthandFunction<SlotPropsDataType> = (value, options) =>\n  slot.optional<SlotPropsDataType>(value, {\n    ...options,\n    renderByDefault: options?.required,\n    // elementType as undefined is the way to identify between a slot and a resolveShorthand call\n    // in the case elementType is undefined assertSlots will fail, ensuring it'll only work with slot method.\n    elementType: undefined!,\n  }) as WithoutSlotRenderFunction<SlotPropsDataType>;\n"],"names":["slot","resolveShorthand","value","options","optional","renderByDefault","required","elementType","undefined"],"mappings":"AAAA,YAAYA,UAAU,UAAU;AAyBhC;;;;;;;;CAQC,GACD,mDAAmD;AACnD,OAAO,MAAMC,mBAAgE,CAACC,OAAOC,UACnFH,KAAKI,QAAQ,CAAoBF,OAAO;QACtC,GAAGC,OAAO;QACVE,eAAe,EAAEF,oBAAAA,8BAAAA,QAASG,QAAQ;QAClC,6FAA6F;QAC7F,yGAAyG;QACzGC,aAAaC;IACf,GAAmD"}
+{"version":3,"sources":["resolveShorthand.ts"],"sourcesContent":["import * as slot from '../slot';\nimport type { SlotShorthandValue, UnknownSlotProps } from '../types';\n\n/**\n * @deprecated - use slot.always or slot.optional combined with assertSlots instead\n */\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true\n  ? { required: true; defaultProps?: Props }\n  : { required?: Required; defaultProps?: Props };\n\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  // eslint-disable-next-line deprecation/deprecation\n  <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;\n  // eslint-disable-next-line deprecation/deprecation\n  <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | P\n    | undefined;\n};\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 *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */\n// eslint-disable-next-line deprecation/deprecation\nexport const resolveShorthand: ResolveShorthandFunction<UnknownSlotProps> = (value, options) =>\n  slot.optional<UnknownSlotProps>(value, {\n    ...options,\n    renderByDefault: options?.required,\n    // elementType as undefined is the way to identify between a slot and a resolveShorthand call\n    // in the case elementType is undefined assertSlots will fail, ensuring it'll only work with slot method.\n    elementType: undefined!,\n  });\n"],"names":["slot","resolveShorthand","value","options","optional","renderByDefault","required","elementType","undefined"],"mappings":"AAAA,YAAYA,UAAU,UAAU;AAsBhC;;;;;;;;CAQC,GACD,mDAAmD;AACnD,OAAO,MAAMC,mBAA+D,CAACC,OAAOC,UAClFH,KAAKI,QAAQ,CAAmBF,OAAO;QACrC,GAAGC,OAAO;QACVE,eAAe,EAAEF,oBAAAA,8BAAAA,QAASG,QAAQ;QAClC,6FAA6F;QAC7F,yGAAyG;QACzGC,aAAaC;IACf,GAAG"}

package/lib/compose/getIntrinsicElementProps.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getIntrinsicElementProps.ts"],"sourcesContent":["import * as React from 'react';\nimport { getNativeElementProps } from '../utils/getNativeElementProps';\nimport type { InferredElementRefType, SlotPropsDataType } from './types';\nimport type { DistributiveOmit } from '../utils/types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype HTMLAttributes = React.HTMLAttributes<any>;\n\n/**\n * Given an element tagname and user props, filters the props to only allowed props for the given\n * element type.\n *\n * Equivalent to {@link getNativeElementProps}, but more type-safe.\n */\nexport const getIntrinsicElementProps = <\n  Props extends SlotPropsDataType,\n  ExcludedPropKeys extends Extract<keyof Props, string> = never,\n>(\n  /** The slot's default element type (e.g. 'div') */\n  tagName: NonNullable<Props['as']>,\n  /** The component's props object */\n  props: Props & React.RefAttributes<InferredElementRefType<Props>>,\n  /** List of native props to exclude from the returned value */\n  excludedPropNames?: ExcludedPropKeys[],\n) => {\n  // eslint-disable-next-line deprecation/deprecation\n  return getNativeElementProps<\n    DistributiveOmit<Props, Exclude<keyof Props, keyof HTMLAttributes | keyof SlotPropsDataType> | ExcludedPropKeys>\n  >(props.as ?? tagName, props, excludedPropNames);\n};\n"],"names":["React","getNativeElementProps","getIntrinsicElementProps","tagName","props","excludedPropNames","as"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,qBAAqB,QAAQ,iCAAiC;AAOvE;;;;;CAKC,GACD,OAAO,MAAMC,2BAA2B,CAItC,iDAAiD,GACjDC,SACA,iCAAiC,GACjCC,OACA,4DAA4D,GAC5DC;QAKED;IAHF,mDAAmD;IACnD,OAAOH,sBAELG,CAAAA,YAAAA,MAAME,EAAE,cAARF,uBAAAA,YAAYD,SAASC,OAAOC;AAChC,EAAE"}
+{"version":3,"sources":["getIntrinsicElementProps.ts"],"sourcesContent":["import * as React from 'react';\nimport { getNativeElementProps } from '../utils/getNativeElementProps';\nimport type { InferredElementRefType, UnknownSlotProps } from './types';\nimport type { DistributiveOmit } from '../utils/types';\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype HTMLAttributes = React.HTMLAttributes<any>;\n\n/**\n * Given an element tagname and user props, filters the props to only allowed props for the given\n * element type.\n *\n * Equivalent to {@link getNativeElementProps}, but more type-safe.\n */\nexport const getIntrinsicElementProps = <\n  Props extends UnknownSlotProps,\n  ExcludedPropKeys extends Extract<keyof Props, string> = never,\n>(\n  /** The slot's default element type (e.g. 'div') */\n  tagName: NonNullable<Props['as']>,\n  /** The component's props object */\n  props: Props & React.RefAttributes<InferredElementRefType<Props>>,\n  /** List of native props to exclude from the returned value */\n  excludedPropNames?: ExcludedPropKeys[],\n) => {\n  // eslint-disable-next-line deprecation/deprecation\n  return getNativeElementProps<\n    DistributiveOmit<Props, Exclude<keyof Props, keyof HTMLAttributes | keyof UnknownSlotProps> | ExcludedPropKeys>\n  >(props.as ?? tagName, props, excludedPropNames);\n};\n"],"names":["React","getNativeElementProps","getIntrinsicElementProps","tagName","props","excludedPropNames","as"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,qBAAqB,QAAQ,iCAAiC;AAOvE;;;;;CAKC,GACD,OAAO,MAAMC,2BAA2B,CAItC,iDAAiD,GACjDC,SACA,iCAAiC,GACjCC,OACA,4DAA4D,GAC5DC;QAKED;IAHF,mDAAmD;IACnD,OAAOH,sBAELG,CAAAA,YAAAA,MAAME,EAAE,cAARF,uBAAAA,YAAYD,SAASC,OAAOC;AAChC,EAAE"}

package/lib/compose/isResolvedShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["isResolvedShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { ExtractSlotProps, Slot, SlotPropsDataType } from './types';\n\n/**\n * Guard method that validates if a shorthand is a slot\n * can be used to extends properties provided by a slot\n *\n * @example\n * ```\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(event => {\n *     if (isResolvedShorthand(backdrop)) {\n *        backdrop.onClick?.(event)\n *      }\n *      // do something after passing click down the line\n *    }),\n *  },\n * })\n * ```\n * @example\n * ```\n * const handleBackDropClick = (event) => {\n *  // do your thing\n * }\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(\n *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)\n *    )\n * })\n * ```\n */\nexport function isResolvedShorthand<Shorthand extends Slot<SlotPropsDataType>>(\n  shorthand?: Shorthand,\n): shorthand is ExtractSlotProps<Shorthand> {\n  return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && !isValidElement(shorthand);\n}\n"],"names":["isValidElement","isResolvedShorthand","shorthand","Array","isArray"],"mappings":"AAAA,SAASA,cAAc,QAAQ,QAAQ;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BC,GACD,OAAO,SAASC,oBACdC,SAAqB;IAErB,OAAOA,cAAc,QAAQ,OAAOA,cAAc,YAAY,CAACC,MAAMC,OAAO,CAACF,cAAc,CAACF,eAAeE;AAC7G"}
+{"version":3,"sources":["isResolvedShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { ExtractSlotProps, Slot, UnknownSlotProps } from './types';\n\n/**\n * Guard method that validates if a shorthand is a slot\n * can be used to extends properties provided by a slot\n *\n * @example\n * ```\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(event => {\n *     if (isResolvedShorthand(backdrop)) {\n *        backdrop.onClick?.(event)\n *      }\n *      // do something after passing click down the line\n *    }),\n *  },\n * })\n * ```\n * @example\n * ```\n * const handleBackDropClick = (event) => {\n *  // do your thing\n * }\n * const backdropSlot = resolveShorthand(backdrop, {\n *  defaultProps: {\n *    onClick: useEventCallback(\n *      mergeCallbacks(isResolvedShorthand(backdrop) ? backdrop.onClick : undefined, handleBackdropClick)\n *    )\n * })\n * ```\n */\nexport function isResolvedShorthand<Shorthand extends Slot<UnknownSlotProps>>(\n  shorthand?: Shorthand,\n): shorthand is ExtractSlotProps<Shorthand> {\n  return shorthand !== null && typeof shorthand === 'object' && !Array.isArray(shorthand) && !isValidElement(shorthand);\n}\n"],"names":["isValidElement","isResolvedShorthand","shorthand","Array","isArray"],"mappings":"AAAA,SAASA,cAAc,QAAQ,QAAQ;AAGvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BC,GACD,OAAO,SAASC,oBACdC,SAAqB;IAErB,OAAOA,cAAc,QAAQ,OAAOA,cAAc,YAAY,CAACC,MAAMC,OAAO,CAACF,cAAc,CAACF,eAAeE;AAC7G"}

package/lib/compose/slot.js

@@ -49,7 +49,7 @@ import { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constan
  * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object
  * @param value - the value of the slot, it can be a slot shorthand or a slot properties object
  */ export function resolveShorthand(value) {
-    if (typeof value === 'string' || typeof value === 'number' || isIterable(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
     React.isValidElement(value)) {
         return {
             children: value
@@ -65,4 +65,3 @@ Slot shorthands can be strings, numbers, arrays or JSX elements`);
     }
     return value;
 }
-const isIterable = (value)=>typeof value === 'object' && value !== null && Symbol.iterator in value;

package/lib/compose/slot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["slot.ts"],"sourcesContent":["import type {\n  AsIntrinsicElement,\n  SlotComponentType,\n  SlotRenderFunction,\n  SlotShorthandValue,\n  SlotPropsDataType,\n  InferredElementRefType,\n} from './types';\nimport * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n\nexport type SlotOptions<Props extends SlotPropsDataType> = {\n  elementType:\n    | React.ComponentType<Props>\n    | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  defaultProps?: Partial<Props & { ref?: React.Ref<InferredElementRefType<Props>> }>;\n};\n\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.\n */\nexport function always<Props extends SlotPropsDataType>(\n  value: Props | SlotShorthandValue | undefined,\n  options: SlotOptions<Props>,\n): SlotComponentType<Props> {\n  const { defaultProps, elementType } = options;\n\n  const props = resolveShorthand(value);\n\n  /**\n   * Casting is required here as SlotComponentType is a function, not an object.\n   * Although SlotComponentType has a function signature, it is still just an object.\n   * This is required to make a slot callable (JSX compatible), this is the exact same approach\n   * that is used on `@types/react` components\n   */\n  const propsWithMetadata = {\n    ...defaultProps,\n    ...props,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: elementType,\n  } as SlotComponentType<Props>;\n\n  if (props && typeof props.children === 'function') {\n    propsWithMetadata[SLOT_RENDER_FUNCTION_SYMBOL] = props.children as SlotRenderFunction<Props>;\n    propsWithMetadata.children = defaultProps?.children;\n  }\n\n  return propsWithMetadata;\n}\n\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided\n * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.\n * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`\n * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object\n * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content\n * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`\n */\nexport function optional<Props extends SlotPropsDataType>(\n  value: Props | SlotShorthandValue | undefined | null,\n  options: { renderByDefault?: boolean } & SlotOptions<Props>,\n): SlotComponentType<Props> | undefined {\n  if (value === null || (value === undefined && !options.renderByDefault)) {\n    return undefined;\n  }\n  return always(value, options);\n}\n\n/**\n * Helper function that converts a slot shorthand or properties to a slot properties object\n * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object\n * @param value - the value of the slot, it can be a slot shorthand or a slot properties object\n */\nexport function resolveShorthand<Props extends SlotPropsDataType | null | undefined>(\n  value: Props | SlotShorthandValue,\n): Props {\n  if (\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    isIterable(value) ||\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    React.isValidElement<any>(value)\n  ) {\n    return { children: value } as Props;\n  }\n  if (value && typeof value !== 'object' && process.env.NODE_ENV !== 'production') {\n    // TODO: would be nice to have a link to slot documentation in this error message\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n      @fluentui/react-utilities [slot.${resolveShorthand.name}]:\n      A slot got an invalid value \"${value}\" (${typeof value}).\n      A valid value for a slot is a slot shorthand or slot properties object.\n      Slot shorthands can be strings, numbers, arrays or JSX elements\n    `);\n  }\n\n  return value;\n}\n\nconst isIterable = (value: unknown): value is Iterable<unknown> =>\n  typeof value === 'object' && value !== null && Symbol.iterator in value;\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","always","value","options","defaultProps","elementType","props","resolveShorthand","propsWithMetadata","children","optional","undefined","renderByDefault","isIterable","isValidElement","process","env","NODE_ENV","console","error","name","Symbol","iterator"],"mappings":"AAQA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,EAAEC,2BAA2B,QAAQ,cAAc;AASpF;;;;;;;CAOC,GACD,OAAO,SAASC,OACdC,KAA6C,EAC7CC,OAA2B;IAE3B,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGF;IAEtC,MAAMG,QAAQC,iBAAiBL;IAE/B;;;;;GAKC,GACD,MAAMM,oBAAoB;QACxB,GAAGJ,YAAY;QACf,GAAGE,KAAK;QACR,CAACP,yBAAyB,EAAEM;IAC9B;IAEA,IAAIC,SAAS,OAAOA,MAAMG,QAAQ,KAAK,YAAY;QACjDD,iBAAiB,CAACR,4BAA4B,GAAGM,MAAMG,QAAQ;QAC/DD,kBAAkBC,QAAQ,GAAGL,yBAAAA,mCAAAA,aAAcK,QAAQ;IACrD;IAEA,OAAOD;AACT;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASE,SACdR,KAAoD,EACpDC,OAA2D;IAE3D,IAAID,UAAU,QAASA,UAAUS,aAAa,CAACR,QAAQS,eAAe,EAAG;QACvE,OAAOD;IACT;IACA,OAAOV,OAAOC,OAAOC;AACvB;AAEA;;;;CAIC,GACD,OAAO,SAASI,iBACdL,KAAiC;IAEjC,IACE,OAAOA,UAAU,YACjB,OAAOA,UAAU,YACjBW,WAAWX,UACX,8DAA8D;IAC9DJ,MAAMgB,cAAc,CAAMZ,QAC1B;QACA,OAAO;YAAEO,UAAUP;QAAM;IAC3B;IACA,IAAIA,SAAS,OAAOA,UAAU,YAAYa,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QAC/E,iFAAiF;QACjF,sCAAsC;QACtCC,QAAQC,KAAK,CAAuB,CAAC,gCACH,EAAEZ,iBAAiBa,IAAI,CAAC;6BAC3B,EAAElB,MAAM,GAAG,EAAE,OAAOA,MAAM;;+DAGzD,CAAC;IACH;IAEA,OAAOA;AACT;AAEA,MAAMW,aAAa,CAACX,QAClB,OAAOA,UAAU,YAAYA,UAAU,QAAQmB,OAAOC,QAAQ,IAAIpB"}
+{"version":3,"sources":["slot.ts"],"sourcesContent":["import type {\n  AsIntrinsicElement,\n  SlotComponentType,\n  SlotRenderFunction,\n  SlotShorthandValue,\n  UnknownSlotProps,\n} from './types';\nimport * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n\nexport type SlotOptions<Props extends UnknownSlotProps> = {\n  elementType:\n    | React.ComponentType<Props>\n    | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  defaultProps?: Partial<Props>;\n};\n\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.\n */\nexport function always<Props extends UnknownSlotProps>(\n  value: Props | SlotShorthandValue | undefined,\n  options: SlotOptions<Props>,\n): SlotComponentType<Props> {\n  const { defaultProps, elementType } = options;\n\n  const props = resolveShorthand(value);\n\n  /**\n   * Casting is required here as SlotComponentType is a function, not an object.\n   * Although SlotComponentType has a function signature, it is still just an object.\n   * This is required to make a slot callable (JSX compatible), this is the exact same approach\n   * that is used on `@types/react` components\n   */\n  const propsWithMetadata = {\n    ...defaultProps,\n    ...props,\n    [SLOT_ELEMENT_TYPE_SYMBOL]: elementType,\n  } as SlotComponentType<Props>;\n\n  if (props && typeof props.children === 'function') {\n    propsWithMetadata[SLOT_RENDER_FUNCTION_SYMBOL] = props.children as SlotRenderFunction<Props>;\n    propsWithMetadata.children = defaultProps?.children;\n  }\n\n  return propsWithMetadata;\n}\n\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided\n * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.\n * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`\n * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object\n * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content\n * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`\n */\nexport function optional<Props extends UnknownSlotProps>(\n  value: Props | SlotShorthandValue | undefined | null,\n  options: { renderByDefault?: boolean } & SlotOptions<Props>,\n): SlotComponentType<Props> | undefined {\n  if (value === null || (value === undefined && !options.renderByDefault)) {\n    return undefined;\n  }\n  return always(value, options);\n}\n\n/**\n * Helper function that converts a slot shorthand or properties to a slot properties object\n * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object\n * @param value - the value of the slot, it can be a slot shorthand or a slot properties object\n */\nexport function resolveShorthand<Props extends UnknownSlotProps | null | undefined>(\n  value: Props | SlotShorthandValue,\n): Props {\n  if (\n    typeof value === 'string' ||\n    typeof value === 'number' ||\n    Array.isArray(value) ||\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    React.isValidElement<any>(value)\n  ) {\n    return { children: value } as Props;\n  }\n  if (value && typeof value !== 'object' && process.env.NODE_ENV !== 'production') {\n    // TODO: would be nice to have a link to slot documentation in this error message\n    // eslint-disable-next-line no-console\n    console.error(/** #__DE-INDENT__ */ `\n      @fluentui/react-utilities [slot.${resolveShorthand.name}]:\n      A slot got an invalid value \"${value}\" (${typeof value}).\n      A valid value for a slot is a slot shorthand or slot properties object.\n      Slot shorthands can be strings, numbers, arrays or JSX elements\n    `);\n  }\n\n  return value;\n}\n"],"names":["React","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","always","value","options","defaultProps","elementType","props","resolveShorthand","propsWithMetadata","children","optional","undefined","renderByDefault","Array","isArray","isValidElement","process","env","NODE_ENV","console","error","name"],"mappings":"AAOA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,EAAEC,2BAA2B,QAAQ,cAAc;AASpF;;;;;;;CAOC,GACD,OAAO,SAASC,OACdC,KAA6C,EAC7CC,OAA2B;IAE3B,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGF;IAEtC,MAAMG,QAAQC,iBAAiBL;IAE/B;;;;;GAKC,GACD,MAAMM,oBAAoB;QACxB,GAAGJ,YAAY;QACf,GAAGE,KAAK;QACR,CAACP,yBAAyB,EAAEM;IAC9B;IAEA,IAAIC,SAAS,OAAOA,MAAMG,QAAQ,KAAK,YAAY;QACjDD,iBAAiB,CAACR,4BAA4B,GAAGM,MAAMG,QAAQ;QAC/DD,kBAAkBC,QAAQ,GAAGL,yBAAAA,mCAAAA,aAAcK,QAAQ;IACrD;IAEA,OAAOD;AACT;AAEA;;;;;;;;;;;;CAYC,GACD,OAAO,SAASE,SACdR,KAAoD,EACpDC,OAA2D;IAE3D,IAAID,UAAU,QAASA,UAAUS,aAAa,CAACR,QAAQS,eAAe,EAAG;QACvE,OAAOD;IACT;IACA,OAAOV,OAAOC,OAAOC;AACvB;AAEA;;;;CAIC,GACD,OAAO,SAASI,iBACdL,KAAiC;IAEjC,IACE,OAAOA,UAAU,YACjB,OAAOA,UAAU,YACjBW,MAAMC,OAAO,CAACZ,UACd,8DAA8D;IAC9DJ,MAAMiB,cAAc,CAAMb,QAC1B;QACA,OAAO;YAAEO,UAAUP;QAAM;IAC3B;IACA,IAAIA,SAAS,OAAOA,UAAU,YAAYc,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QAC/E,iFAAiF;QACjF,sCAAsC;QACtCC,QAAQC,KAAK,CAAuB,CAAC,gCACH,EAAEb,iBAAiBc,IAAI,CAAC;6BAC3B,EAAEnB,MAAM,GAAG,EAAE,OAAOA,MAAM;;+DAGzD,CAAC;IACH;IAEA,OAAOA;AACT"}

package/lib/compose/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\nimport {\n  ComponentType,\n  DistributiveOmit,\n  FunctionComponent,\n  ReactNode,\n  ReplaceNullWithUndefined,\n} from '../utils/types';\n\n/**\n * @internal\n *\n * This should ONLY be used in type templates as in `extends SlotPropsDataType`;\n * it shouldn't be used as a component's Slot props type.\n */\nexport type SlotPropsDataType = {\n  as?: keyof JSX.IntrinsicElements;\n  children?: ReactNode;\n};\n\nexport type SlotRenderFunction<Props> = (Component: React.ElementType<Props>, props: Omit<Props, 'as'>) => 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, SlotPropsDataType | SlotShorthandValue | null | undefined>;\n\n/**\n * The shorthand value of a slot allows specifying its child\n */\nexport type SlotShorthandValue = React.ReactElement | string | number | Iterable<ReactNode> | React.ReactPortal;\n\n/**\n * @deprecated - SlotPropsDataType instead\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 * @internal\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 */\nexport type WithSlotRenderFunction<Props> = Omit<Props, 'children'> & {\n  children?: ('children' extends keyof Props ? Props['children'] : never) | SlotRenderFunction<Props>;\n};\n\n/**\n * @internal\n */\nexport type WithoutSlotRenderFunction<Props> = Props extends unknown\n  ? 'children' extends keyof Props\n    ? Omit<Props, 'children'> & { children?: Exclude<Props['children'], Function> }\n    : Props\n  : never;\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 EmptyIntrinsicElements =\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 IntrinsicElementProps<Type extends keyof JSX.IntrinsicElements> = Type extends EmptyIntrinsicElements\n  ? PropsWithoutChildren<React.PropsWithRef<JSX.IntrinsicElements[Type]>>\n  : React.PropsWithRef<JSX.IntrinsicElements[Type]>;\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  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  Type extends keyof JSX.IntrinsicElements | ComponentType<any> | SlotPropsDataType,\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<IntrinsicElementProps<Type>>\n            : Type extends ComponentType<infer Props> // Component types like `typeof Button`\n            ? Props extends SlotPropsDataType\n              ? Props\n              : WithSlotRenderFunction<Props>\n            : Type // Props types like `ButtonProps`\n        >\n      | (AlternateAs extends unknown\n          ? { as: AlternateAs } & WithSlotRenderFunction<IntrinsicElementProps<AlternateAs>>\n          : never)\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 * 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 ? DistributiveOmit<P, 'ref'> : P;\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 PropsWithoutChildren<P> = 'children' extends keyof P ? DistributiveOmit<P, 'children'> : 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  // Note: the `Omit<Slots, Primary & 'root'>` here 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  Omit<Slots, Primary & 'root'> &\n    // Include all of the props of the primary slot inline in the component's props\n    PropsWithoutRef<WithoutSlotRenderFunction<ExtractSlotProps<Slots[Primary]>>>;\n\n/**\n * Defines the State object of a component given its slots.\n */\nexport type ComponentState<Slots extends SlotPropsRecord> = {\n  /**\n   * @deprecated\n   * The base element type for each slot.\n   * This property is deprecated and will be removed in a future version.\n   * The slot base element type is declared through `slot.*(slotShorthand, {elementType: ElementType})` instead.\n   */\n  components: {\n    [Key in keyof Slots]-?: React.ElementType;\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    WithoutSlotRenderFunction<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 * Infers the element type from props that are declared using ComponentProps.\n */\nexport type InferredElementRefType<Props> = ObscureEventName extends keyof Props\n  ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element>\n    ? Element\n    : never\n  : never;\n\n/**\n * Return type for `React.forwardRef`, including inference of the proper typing for the ref.\n *\n * Note: {@link React.RefAttributes} is {@link https://github.com/DefinitelyTyped/DefinitelyTyped/discussions/69756 | leaking string references} into forwardRef components, forwardRef component do not support string refs.\n */\nexport type ForwardRefComponent<Props> = FunctionComponent<Props & React.RefAttributes<InferredElementRefType<Props>>>;\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\n/**\n * A definition of a slot, as a component, very similar to how a React component is declared,\n * but with some additional metadata that is used to determine how to render the slot.\n */\nexport type SlotComponentType<Props extends SlotPropsDataType> = WithoutSlotRenderFunction<Props> &\n  FunctionComponent<{ children?: ReactNode }> & {\n    /**\n     * @internal\n     */\n    [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<Props>;\n    /**\n     * @internal\n     */\n    [SLOT_ELEMENT_TYPE_SYMBOL]:\n      | ComponentType<Props>\n      | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n  };\n\n/**\n * Data type for event handlers. It makes data a discriminated union, where each object requires `event` and `type` property.\n * - `event` is the specific event type\n * - `type` is a string literal. It serves as a clear identifier of the event type that reflects the component's state when the event occurred.\n *    For example, the Tree component's `onNavigation` event handler has different `type` for different key presses: `{ event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowRight } | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowLeft }`.\n *    Developers can use the `type` property to identify and filter events of interest.\n * See RFC event-handlers-event-type.md for more details.\n *\n * Example usage:\n * type OnOpenChangeData = (\n *   | EventData\\<'click', React.MouseEvent\\<MyComponentElement\\>\\>\n *   | EventData\\<'keydown', React.KeyboardEvent\\<MyComponentElement\\>\\>\n * ) & \\{ open: boolean; \\};\n */\nexport type EventData<Type extends string, TEvent> =\n  | { type: undefined; event: React.SyntheticEvent | Event }\n  | { type: Type; event: TEvent };\n\n/**\n * Type for props that are event handlers.\n * See RFC event-handlers-event-type.md for more details.\n *\n * Example usage:\n * type OnSomeEventData = EventData\\<'click', React.MouseEvent\\<MyComponentElement\\>\\> & \\{ open: boolean; \\};\n * type SomeProps = \\{ onSomeEvent?: EventHandler\\<OnSomeEventData\\>; \\};\n */\nexport type EventHandler<TData extends EventData<string, unknown>> = (\n  ev: React.SyntheticEvent | Event,\n  data: TData,\n) => void;\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\nimport { DistributiveOmit, ReplaceNullWithUndefined } from '../utils/types';\n\nexport type SlotRenderFunction<Props> = (\n  Component: React.ElementType<Props>,\n  props: Omit<Props, '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.ReactNode[] | 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> = Props & {\n  children?: (Props extends { children?: unknown } ? Props['children'] : never) | 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 EmptyIntrinsicElements =\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 IntrinsicElementProps<Type extends keyof JSX.IntrinsicElements> = Type extends EmptyIntrinsicElements\n  ? PropsWithoutChildren<React.PropsWithRef<JSX.IntrinsicElements[Type]>>\n  : React.PropsWithRef<JSX.IntrinsicElements[Type]>;\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<IntrinsicElementProps<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<IntrinsicElementProps<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 * 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 ? DistributiveOmit<P, 'ref'> : P;\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 PropsWithoutChildren<P> = 'children' extends keyof P ? DistributiveOmit<P, 'children'> : 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 * 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 * Infers the element type from props that are declared using ComponentProps.\n */\nexport type InferredElementRefType<Props> = ObscureEventName extends keyof Props\n  ? Required<Props>[ObscureEventName] extends React.PointerEventHandler<infer Element>\n    ? Element\n    : never\n  : never;\n\n/**\n * Return type for `React.forwardRef`, including inference of the proper typing for the ref.\n */\nexport type ForwardRefComponent<Props> = React.ForwardRefExoticComponent<\n  Props & React.RefAttributes<InferredElementRefType<Props>>\n>;\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\n/**\n * A definition of a slot, as a component, very similar to how a React component is declared,\n * but with some additional metadata that is used to determine how to render the slot.\n */\nexport type SlotComponentType<Props extends UnknownSlotProps> = Props & {\n  /**\n   * **NOTE**: Slot components are not callable.\n   */\n  (props: React.PropsWithChildren<{}>): React.ReactElement | null;\n  /**\n   * @internal\n   */\n  [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<Props>;\n  /**\n   * @internal\n   */\n  [SLOT_ELEMENT_TYPE_SYMBOL]:\n    | React.ComponentType<Props>\n    | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);\n};\n\n/**\n * Data type for event handlers. It makes data a discriminated union, where each object requires `event` and `type` property.\n * - `event` is the specific event type\n * - `type` is a string literal. It serves as a clear identifier of the event type that reflects the component's state when the event occurred.\n *    For example, the Tree component's `onNavigation` event handler has different `type` for different key presses: `{ event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowRight } | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowLeft }`.\n *    Developers can use the `type` property to identify and filter events of interest.\n * See RFC event-handlers-event-type.md for more details.\n *\n * Example usage:\n * type OnOpenChangeData = (\n *   | EventData\\<'click', React.MouseEvent\\<MyComponentElement\\>\\>\n *   | EventData\\<'keydown', React.KeyboardEvent\\<MyComponentElement\\>\\>\n * ) & \\{ open: boolean; \\};\n */\nexport type EventData<Type extends string, TEvent> =\n  | { type: undefined; event: React.SyntheticEvent | Event }\n  | { type: Type; event: TEvent };\n\n/**\n * Type for props that are event handlers.\n * See RFC event-handlers-event-type.md for more details.\n *\n * Example usage:\n * type OnSomeEventData = EventData\\<'click', React.MouseEvent\\<MyComponentElement\\>\\> & \\{ open: boolean; \\};\n * type SomeProps = \\{ onSomeEvent?: EventHandler\\<OnSomeEventData\\>; \\};\n */\nexport type EventHandler<TData extends EventData<string, unknown>> = (\n  ev: React.SyntheticEvent | Event,\n  data: TData,\n) => void;\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}

package/lib/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  slot,\n  isSlot,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlotsNext,\n  assertSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  resolveShorthand,\n  isResolvedShorthand,\n  getIntrinsicElementProps,\n  SLOT_ELEMENT_TYPE_SYMBOL,\n  SLOT_RENDER_FUNCTION_SYMBOL,\n} from './compose/index';\nexport type {\n  ExtractSlotProps,\n  ComponentProps,\n  ComponentState,\n  ForwardRefComponent,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandFunction,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandOptions,\n  Slot,\n  // eslint-disable-next-line deprecation/deprecation\n  Slots,\n  SlotClassNames,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  SlotShorthandValue,\n  // eslint-disable-next-line deprecation/deprecation\n  UnknownSlotProps,\n  SlotComponentType,\n  SlotOptions,\n  InferredElementRefType,\n  EventData,\n  EventHandler,\n} from './compose/index';\n\nexport {\n  IdPrefixProvider,\n  resetIdsForTests,\n  useAnimationFrame,\n  useControllableState,\n  useEventCallback,\n  useFirstMount,\n  useForceUpdate,\n  useId,\n  useIsomorphicLayoutEffect,\n  useMergedRefs,\n  useOnClickOutside,\n  useOnScrollOutside,\n  usePrevious,\n  useScrollbarWidth,\n  useTimeout,\n} from './hooks/index';\nexport type { RefObjectFunction, UseControllableStateOptions, UseOnClickOrScrollOutsideOptions } from './hooks/index';\n\nexport { canUseDOM, useIsSSR, SSRProvider } from './ssr/index';\n\nexport {\n  clamp,\n  // eslint-disable-next-line deprecation/deprecation\n  getNativeElementProps,\n  getPartitionedNativeProps,\n  getRTLSafeKey,\n  mergeCallbacks,\n  isHTMLElement,\n  isInteractiveHTMLElement,\n  omit,\n  createPriorityQueue,\n} from './utils/index';\n\nexport type { DistributiveOmit, UnionToIntersection } from './utils/types';\n\nexport type { PriorityQueue } from './utils/priorityQueue';\n\nexport { applyTriggerPropsToChildren, getTriggerChild, isFluentTrigger } from './trigger/index';\n\nexport type { FluentTriggerComponent, TriggerProps } from './trigger/index';\n\n/**\n * Event utils\n */\nexport type { NativeTouchOrMouseEvent, ReactTouchOrMouseEvent, TouchOrMouseEvent } from './events/index';\nexport { isTouchEvent, isMouseEvent, getEventClientCoords } from './events/index';\n\nexport type {\n  SelectionMode,\n  OnSelectionChangeCallback,\n  OnSelectionChangeData,\n  SelectionItemId,\n  SelectionHookParams,\n  SelectionMethods,\n} from './selection/index';\nexport { useSelection } from './selection/index';\n\nexport { elementContains, setVirtualParent, getParent } from './virtualParent/index';\n"],"names":["slot","isSlot","getSlots","getSlotsNext","assertSlots","resolveShorthand","isResolvedShorthand","getIntrinsicElementProps","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","IdPrefixProvider","resetIdsForTests","useAnimationFrame","useControllableState","useEventCallback","useFirstMount","useForceUpdate","useId","useIsomorphicLayoutEffect","useMergedRefs","useOnClickOutside","useOnScrollOutside","usePrevious","useScrollbarWidth","useTimeout","canUseDOM","useIsSSR","SSRProvider","clamp","getNativeElementProps","getPartitionedNativeProps","getRTLSafeKey","mergeCallbacks","isHTMLElement","isInteractiveHTMLElement","omit","createPriorityQueue","applyTriggerPropsToChildren","getTriggerChild","isFluentTrigger","isTouchEvent","isMouseEvent","getEventClientCoords","useSelection","elementContains","setVirtualParent","getParent"],"mappings":"AAAA,SACEA,IAAI,EACJC,MAAM,EACN,mDAAmD;AACnDC,QAAQ,EACR,mDAAmD;AACnDC,YAAY,EACZC,WAAW,EACX,mDAAmD;AACnDC,gBAAgB,EAChBC,mBAAmB,EACnBC,wBAAwB,EACxBC,wBAAwB,EACxBC,2BAA2B,QACtB,kBAAkB;AA0BzB,SACEC,gBAAgB,EAChBC,gBAAgB,EAChBC,iBAAiB,EACjBC,oBAAoB,EACpBC,gBAAgB,EAChBC,aAAa,EACbC,cAAc,EACdC,KAAK,EACLC,yBAAyB,EACzBC,aAAa,EACbC,iBAAiB,EACjBC,kBAAkB,EAClBC,WAAW,EACXC,iBAAiB,EACjBC,UAAU,QACL,gBAAgB;AAGvB,SAASC,SAAS,EAAEC,QAAQ,EAAEC,WAAW,QAAQ,cAAc;AAE/D,SACEC,KAAK,EACL,mDAAmD;AACnDC,qBAAqB,EACrBC,yBAAyB,EACzBC,aAAa,EACbC,cAAc,EACdC,aAAa,EACbC,wBAAwB,EACxBC,IAAI,EACJC,mBAAmB,QACd,gBAAgB;AAMvB,SAASC,2BAA2B,EAAEC,eAAe,EAAEC,eAAe,QAAQ,kBAAkB;AAQhG,SAASC,YAAY,EAAEC,YAAY,EAAEC,oBAAoB,QAAQ,iBAAiB;AAUlF,SAASC,YAAY,QAAQ,oBAAoB;AAEjD,SAASC,eAAe,EAAEC,gBAAgB,EAAEC,SAAS,QAAQ,wBAAwB"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export {\n  slot,\n  isSlot,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  getSlotsNext,\n  assertSlots,\n  // eslint-disable-next-line deprecation/deprecation\n  resolveShorthand,\n  isResolvedShorthand,\n  getIntrinsicElementProps,\n  SLOT_ELEMENT_TYPE_SYMBOL,\n  SLOT_RENDER_FUNCTION_SYMBOL,\n} from './compose/index';\nexport type {\n  ExtractSlotProps,\n  ComponentProps,\n  ComponentState,\n  ForwardRefComponent,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandFunction,\n  // eslint-disable-next-line deprecation/deprecation\n  ResolveShorthandOptions,\n  Slot,\n  // eslint-disable-next-line deprecation/deprecation\n  Slots,\n  SlotClassNames,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  SlotShorthandValue,\n  UnknownSlotProps,\n  SlotComponentType,\n  SlotOptions,\n  InferredElementRefType,\n  EventData,\n  EventHandler,\n} from './compose/index';\n\nexport {\n  IdPrefixProvider,\n  resetIdsForTests,\n  useAnimationFrame,\n  useControllableState,\n  useEventCallback,\n  useFirstMount,\n  useForceUpdate,\n  useId,\n  useIsomorphicLayoutEffect,\n  useMergedRefs,\n  useOnClickOutside,\n  useOnScrollOutside,\n  usePrevious,\n  useScrollbarWidth,\n  useTimeout,\n} from './hooks/index';\nexport type { RefObjectFunction, UseControllableStateOptions, UseOnClickOrScrollOutsideOptions } from './hooks/index';\n\nexport { canUseDOM, useIsSSR, SSRProvider } from './ssr/index';\n\nexport {\n  clamp,\n  // eslint-disable-next-line deprecation/deprecation\n  getNativeElementProps,\n  getPartitionedNativeProps,\n  getRTLSafeKey,\n  mergeCallbacks,\n  isHTMLElement,\n  isInteractiveHTMLElement,\n  omit,\n  createPriorityQueue,\n} from './utils/index';\n\nexport type { DistributiveOmit, UnionToIntersection } from './utils/types';\n\nexport type { PriorityQueue } from './utils/priorityQueue';\n\nexport { applyTriggerPropsToChildren, getTriggerChild, isFluentTrigger } from './trigger/index';\n\nexport type { FluentTriggerComponent, TriggerProps } from './trigger/index';\n\n/**\n * Event utils\n */\nexport type { NativeTouchOrMouseEvent, ReactTouchOrMouseEvent, TouchOrMouseEvent } from './events/index';\nexport { isTouchEvent, isMouseEvent, getEventClientCoords } from './events/index';\n\nexport type {\n  SelectionMode,\n  OnSelectionChangeCallback,\n  OnSelectionChangeData,\n  SelectionItemId,\n  SelectionHookParams,\n  SelectionMethods,\n} from './selection/index';\nexport { useSelection } from './selection/index';\n\nexport { elementContains, setVirtualParent, getParent } from './virtualParent/index';\n"],"names":["slot","isSlot","getSlots","getSlotsNext","assertSlots","resolveShorthand","isResolvedShorthand","getIntrinsicElementProps","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_RENDER_FUNCTION_SYMBOL","IdPrefixProvider","resetIdsForTests","useAnimationFrame","useControllableState","useEventCallback","useFirstMount","useForceUpdate","useId","useIsomorphicLayoutEffect","useMergedRefs","useOnClickOutside","useOnScrollOutside","usePrevious","useScrollbarWidth","useTimeout","canUseDOM","useIsSSR","SSRProvider","clamp","getNativeElementProps","getPartitionedNativeProps","getRTLSafeKey","mergeCallbacks","isHTMLElement","isInteractiveHTMLElement","omit","createPriorityQueue","applyTriggerPropsToChildren","getTriggerChild","isFluentTrigger","isTouchEvent","isMouseEvent","getEventClientCoords","useSelection","elementContains","setVirtualParent","getParent"],"mappings":"AAAA,SACEA,IAAI,EACJC,MAAM,EACN,mDAAmD;AACnDC,QAAQ,EACR,mDAAmD;AACnDC,YAAY,EACZC,WAAW,EACX,mDAAmD;AACnDC,gBAAgB,EAChBC,mBAAmB,EACnBC,wBAAwB,EACxBC,wBAAwB,EACxBC,2BAA2B,QACtB,kBAAkB;AAyBzB,SACEC,gBAAgB,EAChBC,gBAAgB,EAChBC,iBAAiB,EACjBC,oBAAoB,EACpBC,gBAAgB,EAChBC,aAAa,EACbC,cAAc,EACdC,KAAK,EACLC,yBAAyB,EACzBC,aAAa,EACbC,iBAAiB,EACjBC,kBAAkB,EAClBC,WAAW,EACXC,iBAAiB,EACjBC,UAAU,QACL,gBAAgB;AAGvB,SAASC,SAAS,EAAEC,QAAQ,EAAEC,WAAW,QAAQ,cAAc;AAE/D,SACEC,KAAK,EACL,mDAAmD;AACnDC,qBAAqB,EACrBC,yBAAyB,EACzBC,aAAa,EACbC,cAAc,EACdC,aAAa,EACbC,wBAAwB,EACxBC,IAAI,EACJC,mBAAmB,QACd,gBAAgB;AAMvB,SAASC,2BAA2B,EAAEC,eAAe,EAAEC,eAAe,QAAQ,kBAAkB;AAQhG,SAASC,YAAY,EAAEC,YAAY,EAAEC,oBAAoB,QAAQ,iBAAiB;AAUlF,SAASC,YAAY,QAAQ,oBAAoB;AAEjD,SAASC,eAAe,EAAEC,gBAAgB,EAAEC,SAAS,QAAQ,wBAAwB"}

package/lib/trigger/applyTriggerPropsToChildren.js.map

@@ -1 +1 @@
-{"version":3,"sources":["applyTriggerPropsToChildren.ts"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\nimport type { TriggerProps } from './types';\n\n/**\n * @internal\n * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.\n */\nexport function applyTriggerPropsToChildren<TriggerChildProps>(\n  children: TriggerProps<TriggerChildProps>['children'],\n  triggerChildProps: TriggerChildProps,\n): React.ReactElement | null {\n  if (typeof children === 'function') {\n    return children(triggerChildProps);\n  } else if (children) {\n    return cloneTriggerTree(children, triggerChildProps);\n  }\n\n  // Components in React should return either JSX elements or \"null\", otherwise React will throw:\n  //   Nothing was returned from render.\n  //   This usually means a return statement is missing. Or, to render nothing, return null.\n  return children || null;\n}\n\n/**\n * Clones a React element tree, and applies the given props to the first grandchild that is not\n * a FluentTriggerComponent or React Fragment (the same element returned by {@link getTriggerChild}).\n */\nfunction cloneTriggerTree<TriggerChildProps>(\n  child: TriggerProps['children'],\n  triggerProps: TriggerChildProps,\n): React.ReactElement {\n  if (!React.isValidElement(child) || child.type === React.Fragment) {\n    throw new Error(\n      'A trigger element must be a single element for this component. ' +\n        \"Please ensure that you're not using React Fragments.\",\n    );\n  }\n\n  if (isFluentTrigger(child)) {\n    const grandchild = cloneTriggerTree(child.props.children, triggerProps);\n    return React.cloneElement(child, undefined, grandchild);\n  } else {\n    return React.cloneElement(child, triggerProps as TriggerChildProps & React.Attributes);\n  }\n}\n"],"names":["React","isFluentTrigger","applyTriggerPropsToChildren","children","triggerChildProps","cloneTriggerTree","child","triggerProps","isValidElement","type","Fragment","Error","grandchild","props","cloneElement","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,eAAe,QAAQ,oBAAoB;AAGpD;;;CAGC,GACD,OAAO,SAASC,4BACdC,QAAqD,EACrDC,iBAAoC;IAEpC,IAAI,OAAOD,aAAa,YAAY;QAClC,OAAOA,SAASC;IAClB,OAAO,IAAID,UAAU;QACnB,OAAOE,iBAAiBF,UAAUC;IACpC;IAEA,+FAA+F;IAC/F,sCAAsC;IACtC,0FAA0F;IAC1F,OAAOD,YAAY;AACrB;AAEA;;;CAGC,GACD,SAASE,iBACPC,KAA+B,EAC/BC,YAA+B;IAE/B,IAAI,CAACP,MAAMQ,cAAc,CAACF,UAAUA,MAAMG,IAAI,KAAKT,MAAMU,QAAQ,EAAE;QACjE,MAAM,IAAIC,MACR,oEACE;IAEN;IAEA,IAAIV,gBAAgBK,QAAQ;QAC1B,MAAMM,aAAaP,iBAAiBC,MAAMO,KAAK,CAACV,QAAQ,EAAEI;QAC1D,OAAOP,MAAMc,YAAY,CAACR,OAAOS,WAAWH;IAC9C,OAAO;QACL,OAAOZ,MAAMc,YAAY,CAACR,OAAOC;IACnC;AACF"}
+{"version":3,"sources":["applyTriggerPropsToChildren.ts"],"sourcesContent":["import * as React from 'react';\nimport { isFluentTrigger } from './isFluentTrigger';\nimport type { TriggerProps } from './types';\n\n/**\n * @internal\n * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.\n */\nexport function applyTriggerPropsToChildren<TriggerChildProps>(\n  children: TriggerProps<TriggerChildProps>['children'],\n  triggerChildProps: TriggerChildProps,\n): React.ReactElement | null {\n  if (typeof children === 'function') {\n    return children(triggerChildProps);\n  } else if (children) {\n    return cloneTriggerTree(children, triggerChildProps);\n  }\n\n  // Components in React should return either JSX elements or \"null\", otherwise React will throw:\n  //   Nothing was returned from render.\n  //   This usually means a return statement is missing. Or, to render nothing, return null.\n  return children || null;\n}\n\n/**\n * Clones a React element tree, and applies the given props to the first grandchild that is not\n * a FluentTriggerComponent or React Fragment (the same element returned by {@link getTriggerChild}).\n */\nfunction cloneTriggerTree<TriggerChildProps>(\n  child: React.ReactNode,\n  triggerProps: TriggerChildProps,\n): React.ReactElement {\n  if (!React.isValidElement(child) || child.type === React.Fragment) {\n    throw new Error(\n      'A trigger element must be a single element for this component. ' +\n        \"Please ensure that you're not using React Fragments.\",\n    );\n  }\n\n  if (isFluentTrigger(child)) {\n    const grandchild = cloneTriggerTree(child.props.children, triggerProps);\n    return React.cloneElement(child, undefined, grandchild);\n  } else {\n    return React.cloneElement(child, triggerProps as TriggerChildProps & React.Attributes);\n  }\n}\n"],"names":["React","isFluentTrigger","applyTriggerPropsToChildren","children","triggerChildProps","cloneTriggerTree","child","triggerProps","isValidElement","type","Fragment","Error","grandchild","props","cloneElement","undefined"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,eAAe,QAAQ,oBAAoB;AAGpD;;;CAGC,GACD,OAAO,SAASC,4BACdC,QAAqD,EACrDC,iBAAoC;IAEpC,IAAI,OAAOD,aAAa,YAAY;QAClC,OAAOA,SAASC;IAClB,OAAO,IAAID,UAAU;QACnB,OAAOE,iBAAiBF,UAAUC;IACpC;IAEA,+FAA+F;IAC/F,sCAAsC;IACtC,0FAA0F;IAC1F,OAAOD,YAAY;AACrB;AAEA;;;CAGC,GACD,SAASE,iBACPC,KAAsB,EACtBC,YAA+B;IAE/B,IAAI,CAACP,MAAMQ,cAAc,CAACF,UAAUA,MAAMG,IAAI,KAAKT,MAAMU,QAAQ,EAAE;QACjE,MAAM,IAAIC,MACR,oEACE;IAEN;IAEA,IAAIV,gBAAgBK,QAAQ;QAC1B,MAAMM,aAAaP,iBAAiBC,MAAMO,KAAK,CAACV,QAAQ,EAAEI;QAC1D,OAAOP,MAAMc,YAAY,CAACR,OAAOS,WAAWH;IAC9C,OAAO;QACL,OAAOZ,MAAMc,YAAY,CAACR,OAAOC;IACnC;AACF"}

package/lib/utils/types.js

@@ -1 +1,21 @@
-import * as React from 'react';
+/**
+ * Helper type that works similar to Omit,
+ * but when modifying an union type it will distribute the omission to all the union members.
+ *
+ * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information
+ */ // Traditional Omit is basically equivalent to => Pick<T, Exclude<keyof T, K>>
+//
+// let's say we have Omit<{ a: string } | { b: string }, 'a'>
+// equivalent to: Pick<{ a: string } | { b: string }, Exclude<keyof ({ a: string } | { b: string }), 'a'>>
+// The expected result would be {} | { b: string }, the omission of 'a' from all the union members,
+// but keyof ({ a: string } | { b: string }) is never as they don't share common keys
+// so  Exclude<never, 'a'> is never,
+// and Pick<{ a: string } | { b: string }, never> is {}.
+//
+// With DistributiveOmit on the other hand it becomes like this:
+// DistributiveOmit<{ a: string } | { b: string }, 'a'>
+// equivalent to: Omit<{ a: string }, 'a'> | Omit<{ b: string }, 'a'>
+// Since every single Omit clause in this case is being applied to a single union member there's no conflicts on keyof evaluation and in the second clause Omit<{ b: string }, 'a'> becomes { b: string },
+// so the result is {} | { b: string }, as expected.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export { };

package/lib/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.ts"],"sourcesContent":["import * as React from 'react';\n\n/**\n * Helper type that works similar to Omit,\n * but when modifying an union type it will distribute the omission to all the union members.\n *\n * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information\n */\n// Traditional Omit is basically equivalent to => Pick<T, Exclude<keyof T, K>>\n//\n// let's say we have Omit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Pick<{ a: string } | { b: string }, Exclude<keyof ({ a: string } | { b: string }), 'a'>>\n// The expected result would be {} | { b: string }, the omission of 'a' from all the union members,\n// but keyof ({ a: string } | { b: string }) is never as they don't share common keys\n// so  Exclude<never, 'a'> is never,\n// and Pick<{ a: string } | { b: string }, never> is {}.\n//\n// With DistributiveOmit on the other hand it becomes like this:\n// DistributiveOmit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Omit<{ a: string }, 'a'> | Omit<{ b: string }, 'a'>\n// Since every single Omit clause in this case is being applied to a single union member there's no conflicts on keyof evaluation and in the second clause Omit<{ b: string }, 'a'> becomes { b: string },\n// so the result is {} | { b: string }, as expected.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : T;\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 * @internal\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 * @internal\n * With react 18, our `children` type starts leaking everywhere and that causes conflicts on component declaration, specially in the `propTypes` property of\n * both `ComponentClass` and `FunctionComponent`.\n *\n * This type substitutes `React.ComponentType` only keeping the function signature, it omits `propTypes`, `displayName` and other properties that are not\n * required for the inference.\n */\nexport type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;\n\n/**\n * @internal\n *\n * On types/react 18 there are two types being delivered,\n * they rely on the typescript version to decide which will be consumed {@link https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b59dc3ac1e2770fbd6cdbb90ba52abe04c168196/types/react/package.json#L10}\n *\n * If TS is higher than 5.0 then the `FunctionComponent` will be returning ReactNode (which we don't support)\n * If TS is below or equal to 5.0 then the `FunctionComponent` will be returning ReactElement | null (which we support)\n *\n * Since it's not possible to have a single type that works for both cases\n * (as ReactNode is more specific, and this will break while evaluating functions),\n * we need to create our own `FunctionComponent` type\n * that will work for both cases.\n *\n * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**\n */\nexport interface FunctionComponent<P> {\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (props: P): any;\n  defaultProps?: Partial<P>;\n  displayName?: string;\n}\n\n/**\n * @internal\n * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**\n */\nexport interface ComponentClass<P = {}, S = React.ComponentState> extends React.StaticLifecycle<P, S> {\n  new (props: P): React.Component<P, S>;\n}\n\n/**\n * @internal\n *\n * on types/react 18 ReactNode becomes a more strict type, which is not compatible with our current implementation. to avoid any issues we are creating our own ReactNode type which allows anything.\n *\n * This type should only be used for inference purposes, and should never be exposed.\n *\n * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**\n *\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type ReactNode = any;\n"],"names":["React"],"mappings":"AAAA,YAAYA,WAAW,QAAQ"}
+{"version":3,"sources":["types.ts"],"sourcesContent":["/**\n * Helper type that works similar to Omit,\n * but when modifying an union type it will distribute the omission to all the union members.\n *\n * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information\n */\n// Traditional Omit is basically equivalent to => Pick<T, Exclude<keyof T, K>>\n//\n// let's say we have Omit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Pick<{ a: string } | { b: string }, Exclude<keyof ({ a: string } | { b: string }), 'a'>>\n// The expected result would be {} | { b: string }, the omission of 'a' from all the union members,\n// but keyof ({ a: string } | { b: string }) is never as they don't share common keys\n// so  Exclude<never, 'a'> is never,\n// and Pick<{ a: string } | { b: string }, never> is {}.\n//\n// With DistributiveOmit on the other hand it becomes like this:\n// DistributiveOmit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Omit<{ a: string }, 'a'> | Omit<{ b: string }, 'a'>\n// Since every single Omit clause in this case is being applied to a single union member there's no conflicts on keyof evaluation and in the second clause Omit<{ b: string }, 'a'> becomes { b: string },\n// so the result is {} | { b: string }, as expected.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type DistributiveOmit<T, K extends keyof any> = T extends unknown ? Omit<T, K> : T;\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 * @internal\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"],"names":[],"mappings":"AAAA;;;;;CAKC,GACD,8EAA8E;AAC9E,EAAE;AACF,6DAA6D;AAC7D,0GAA0G;AAC1G,mGAAmG;AACnG,qFAAqF;AACrF,oCAAoC;AACpC,wDAAwD;AACxD,EAAE;AACF,gEAAgE;AAChE,uDAAuD;AACvD,qEAAqE;AACrE,0MAA0M;AAC1M,oDAAoD;AACpD,8DAA8D;AAC9D,WAW4F"}

package/lib-commonjs/compose/assertSlots.js

@@ -19,7 +19,6 @@ function assertSlots(state) {
    * as we're verifying static properties that will not change between environments
    */ if (process.env.NODE_ENV !== 'production') {
         const typedState = state;
-        // eslint-disable-next-line deprecation/deprecation
         for (const slotName of Object.keys(typedState.components)){
             const slotElement = typedState[slotName];
             if (slotElement === undefined) {
@@ -30,7 +29,6 @@ function assertSlots(state) {
             // FIXME: this slot will still fail to support child render function scenario
             if (!(0, _isSlot.isSlot)(slotElement)) {
                 typedState[slotName] = _slot.always(slotElement, {
-                    // eslint-disable-next-line deprecation/deprecation
                     elementType: typedState.components[slotName]
                 });
                 // eslint-disable-next-line no-console
@@ -41,9 +39,7 @@ Be sure to create slots properly by using "slot.always" or "slot.optional".`);
                 // This means a slot is being declared by using resolveShorthand on the state hook,
                 // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type
                 const { [_constants.SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;
-                // eslint-disable-next-line deprecation/deprecation
                 if (elementType !== typedState.components[slotName]) {
-                    // eslint-disable-next-line deprecation/deprecation
                     slotElement[_constants.SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName];
                     // eslint-disable-next-line no-console
                     console.warn(`@fluentui/react-utilities [${assertSlots.name}]:

package/lib-commonjs/compose/assertSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["assertSlots.js"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport * as slot from './slot';\n/**\n * @internal\n * Assertion method to ensure state slots properties are properly declared.\n * A properly declared slot must be declared by using the `slot` method.\n *\n * @example\n * ```tsx\n * export const renderInput_unstable = (state: InputState) => {\n    assertSlots<InputSlots>(state);\n    return (\n      <state.root>\n        {state.contentBefore && <state.contentBefore />}\n        <state.input />\n        {state.contentAfter && <state.contentAfter />}\n      </state.root>\n    );\n  };\n * ```\n */ export function assertSlots(state) {\n    /**\n   * This verification is not necessary in production\n   * as we're verifying static properties that will not change between environments\n   */ if (process.env.NODE_ENV !== 'production') {\n        const typedState = state;\n        // eslint-disable-next-line deprecation/deprecation\n        for (const slotName of Object.keys(typedState.components)){\n            const slotElement = typedState[slotName];\n            if (slotElement === undefined) {\n                continue;\n            }\n            // this means a slot is being declared without using, slot.always or slot.optional or even resolveShorthand on the state hook,\n            // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n            // FIXME: this slot will still fail to support child render function scenario\n            if (!isSlot(slotElement)) {\n                typedState[slotName] = slot.always(slotElement, {\n                    // eslint-disable-next-line deprecation/deprecation\n                    elementType: typedState.components[slotName]\n                });\n                // eslint-disable-next-line no-console\n                console.warn(`@fluentui/react-utilities [${assertSlots.name}]:\n\"state.${slotName}\" is not a slot!\nBe sure to create slots properly by using \"slot.always\" or \"slot.optional\".`);\n            } else {\n                // This means a slot is being declared by using resolveShorthand on the state hook,\n                // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n                const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;\n                // eslint-disable-next-line deprecation/deprecation\n                if (elementType !== typedState.components[slotName]) {\n                    // eslint-disable-next-line deprecation/deprecation\n                    slotElement[SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName];\n                    // eslint-disable-next-line no-console\n                    console.warn(`@fluentui/react-utilities [${assertSlots.name}]:\n\"state.${slotName}\" element type differs from \"state.components.${slotName}\",\n${elementType} !== ${typedState.components[slotName]}.\nBe sure to create slots properly by using \"slot.always\" or \"slot.optional\" with the correct elementType.`);\n                }\n            }\n        }\n    }\n}\n"],"names":["assertSlots","state","process","env","NODE_ENV","typedState","slotName","Object","keys","components","slotElement","undefined","isSlot","slot","always","elementType","console","warn","name","SLOT_ELEMENT_TYPE_SYMBOL"],"mappings":";;;;+BAsBoBA;;;eAAAA;;;;iEAtBG;2BACkB;wBAClB;gEACD;AAmBX,SAASA,YAAYC,KAAK;IACjC;;;GAGD,GAAG,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAMC,aAAaJ;QACnB,mDAAmD;QACnD,KAAK,MAAMK,YAAYC,OAAOC,IAAI,CAACH,WAAWI,UAAU,EAAE;YACtD,MAAMC,cAAcL,UAAU,CAACC,SAAS;YACxC,IAAII,gBAAgBC,WAAW;gBAC3B;YACJ;YACA,8HAA8H;YAC9H,4JAA4J;YAC5J,6EAA6E;YAC7E,IAAI,CAACC,IAAAA,cAAM,EAACF,cAAc;gBACtBL,UAAU,CAACC,SAAS,GAAGO,MAAKC,MAAM,CAACJ,aAAa;oBAC5C,mDAAmD;oBACnDK,aAAaV,WAAWI,UAAU,CAACH,SAAS;gBAChD;gBACA,sCAAsC;gBACtCU,QAAQC,IAAI,CAAC,CAAC,2BAA2B,EAAEjB,YAAYkB,IAAI,CAAC;OACrE,EAAEZ,SAAS;2EACyD,CAAC;YAChE,OAAO;gBACH,mFAAmF;gBACnF,4JAA4J;gBAC5J,MAAM,EAAE,CAACa,mCAAwB,CAAC,EAAEJ,WAAW,EAAE,GAAGL;gBACpD,mDAAmD;gBACnD,IAAIK,gBAAgBV,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACjD,mDAAmD;oBACnDI,WAAW,CAACS,mCAAwB,CAAC,GAAGd,WAAWI,UAAU,CAACH,SAAS;oBACvE,sCAAsC;oBACtCU,QAAQC,IAAI,CAAC,CAAC,2BAA2B,EAAEjB,YAAYkB,IAAI,CAAC;OACzE,EAAEZ,SAAS,8CAA8C,EAAEA,SAAS;AAC3E,EAAES,YAAY,KAAK,EAAEV,WAAWI,UAAU,CAACH,SAAS,CAAC;wGACmD,CAAC;gBACzF;YACJ;QACJ;IACJ;AACJ"}
+{"version":3,"sources":["assertSlots.js"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport * as slot from './slot';\n/**\n * @internal\n * Assertion method to ensure state slots properties are properly declared.\n * A properly declared slot must be declared by using the `slot` method.\n *\n * @example\n * ```tsx\n * export const renderInput_unstable = (state: InputState) => {\n    assertSlots<InputSlots>(state);\n    return (\n      <state.root>\n        {state.contentBefore && <state.contentBefore />}\n        <state.input />\n        {state.contentAfter && <state.contentAfter />}\n      </state.root>\n    );\n  };\n * ```\n */ export function assertSlots(state) {\n    /**\n   * This verification is not necessary in production\n   * as we're verifying static properties that will not change between environments\n   */ if (process.env.NODE_ENV !== 'production') {\n        const typedState = state;\n        for (const slotName of Object.keys(typedState.components)){\n            const slotElement = typedState[slotName];\n            if (slotElement === undefined) {\n                continue;\n            }\n            // this means a slot is being declared without using, slot.always or slot.optional or even resolveShorthand on the state hook,\n            // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n            // FIXME: this slot will still fail to support child render function scenario\n            if (!isSlot(slotElement)) {\n                typedState[slotName] = slot.always(slotElement, {\n                    elementType: typedState.components[slotName]\n                });\n                // eslint-disable-next-line no-console\n                console.warn(`@fluentui/react-utilities [${assertSlots.name}]:\n\"state.${slotName}\" is not a slot!\nBe sure to create slots properly by using \"slot.always\" or \"slot.optional\".`);\n            } else {\n                // This means a slot is being declared by using resolveShorthand on the state hook,\n                // but the render method is using the new `assertSlots` method. That scenario can be solved by simply updating the slot element with the proper element type\n                const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;\n                if (elementType !== typedState.components[slotName]) {\n                    slotElement[SLOT_ELEMENT_TYPE_SYMBOL] = typedState.components[slotName];\n                    // eslint-disable-next-line no-console\n                    console.warn(`@fluentui/react-utilities [${assertSlots.name}]:\n\"state.${slotName}\" element type differs from \"state.components.${slotName}\",\n${elementType} !== ${typedState.components[slotName]}.\nBe sure to create slots properly by using \"slot.always\" or \"slot.optional\" with the correct elementType.`);\n                }\n            }\n        }\n    }\n}\n"],"names":["assertSlots","state","process","env","NODE_ENV","typedState","slotName","Object","keys","components","slotElement","undefined","isSlot","slot","always","elementType","console","warn","name","SLOT_ELEMENT_TYPE_SYMBOL"],"mappings":";;;;+BAsBoBA;;;eAAAA;;;;iEAtBG;2BACkB;wBAClB;gEACD;AAmBX,SAASA,YAAYC,KAAK;IACjC;;;GAGD,GAAG,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QACzC,MAAMC,aAAaJ;QACnB,KAAK,MAAMK,YAAYC,OAAOC,IAAI,CAACH,WAAWI,UAAU,EAAE;YACtD,MAAMC,cAAcL,UAAU,CAACC,SAAS;YACxC,IAAII,gBAAgBC,WAAW;gBAC3B;YACJ;YACA,8HAA8H;YAC9H,4JAA4J;YAC5J,6EAA6E;YAC7E,IAAI,CAACC,IAAAA,cAAM,EAACF,cAAc;gBACtBL,UAAU,CAACC,SAAS,GAAGO,MAAKC,MAAM,CAACJ,aAAa;oBAC5CK,aAAaV,WAAWI,UAAU,CAACH,SAAS;gBAChD;gBACA,sCAAsC;gBACtCU,QAAQC,IAAI,CAAC,CAAC,2BAA2B,EAAEjB,YAAYkB,IAAI,CAAC;OACrE,EAAEZ,SAAS;2EACyD,CAAC;YAChE,OAAO;gBACH,mFAAmF;gBACnF,4JAA4J;gBAC5J,MAAM,EAAE,CAACa,mCAAwB,CAAC,EAAEJ,WAAW,EAAE,GAAGL;gBACpD,IAAIK,gBAAgBV,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACjDI,WAAW,CAACS,mCAAwB,CAAC,GAAGd,WAAWI,UAAU,CAACH,SAAS;oBACvE,sCAAsC;oBACtCU,QAAQC,IAAI,CAAC,CAAC,2BAA2B,EAAEjB,YAAYkB,IAAI,CAAC;OACzE,EAAEZ,SAAS,8CAA8C,EAAEA,SAAS;AAC3E,EAAES,YAAY,KAAK,EAAEV,WAAWI,UAAU,CAACH,SAAS,CAAC;wGACmD,CAAC;gBACzF;YACJ;QACJ;IACJ;AACJ"}

package/lib-commonjs/compose/deprecated/getSlots.js

@@ -14,14 +14,12 @@ const _omit = require("../../utils/omit");
 const _isSlot = require("../isSlot");
 const _constants = require("../constants");
 function getSlots(state) {
-    const typeState = state;
     // eslint-disable-next-line deprecation/deprecation
     const slots = {};
     const slotProps = {};
-    // eslint-disable-next-line deprecation/deprecation
-    const slotNames = Object.keys(typeState.components);
+    const slotNames = Object.keys(state.components);
     for (const slotName of slotNames){
-        const [slot, props] = getSlot(typeState, slotName);
+        const [slot, props] = getSlot(state, slotName);
         // eslint-disable-next-line deprecation/deprecation
         slots[slotName] = slot;
         slotProps[slotName] = props;
@@ -44,9 +42,7 @@ function getSlot(state, slotName) {
     // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)
     const { as: asProp, children, ...rest } = props;
     const renderFunction = (0, _isSlot.isSlot)(props) ? props[_constants.SLOT_RENDER_FUNCTION_SYMBOL] : undefined;
-    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation
-    // eslint-disable-next-line deprecation/deprecation
-    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
     if (renderFunction || typeof children === 'function') {
         const render = renderFunction || children;
         return [
@@ -57,7 +53,6 @@ function getSlot(state, slotName) {
         ];
     }
     const shouldOmitAsProp = typeof slot === 'string' && asProp;
-    // eslint-disable-next-line deprecation/deprecation
     const slotProps = shouldOmitAsProp ? (0, _omit.omit)(props, [
         'as'
     ]) : props;

package/lib-commonjs/compose/deprecated/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getSlots.js"],"sourcesContent":["import * as React from 'react';\nimport { omit } from '../../utils/omit';\nimport { isSlot } from '../isSlot';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from '../constants';\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 * @deprecated use slot.always or slot.optional combined with assertSlots instead\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */ export function getSlots(state) {\n    const typeState = state;\n    // eslint-disable-next-line deprecation/deprecation\n    const slots = {};\n    const slotProps = {};\n    // eslint-disable-next-line deprecation/deprecation\n    const slotNames = Object.keys(typeState.components);\n    for (const slotName of slotNames){\n        const [slot, props] = getSlot(typeState, slotName);\n        // eslint-disable-next-line deprecation/deprecation\n        slots[slotName] = slot;\n        slotProps[slotName] = props;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    return {\n        slots,\n        slotProps: slotProps\n    };\n}\nfunction getSlot(state, slotName) {\n    var _state_components, _state_components1;\n    const props = state[slotName];\n    if (props === undefined) {\n        return [\n            null,\n            undefined\n        ];\n    }\n    // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n    const { as: asProp, children, ...rest } = props;\n    const renderFunction = isSlot(props) ? props[SLOT_RENDER_FUNCTION_SYMBOL] : undefined;\n    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation\n    // eslint-disable-next-line deprecation/deprecation\n    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];\n    if (renderFunction || typeof children === 'function') {\n        const render = renderFunction || children;\n        return [\n            React.Fragment,\n            {\n                children: render(slot, rest)\n            }\n        ];\n    }\n    const shouldOmitAsProp = typeof slot === 'string' && asProp;\n    // eslint-disable-next-line deprecation/deprecation\n    const slotProps = shouldOmitAsProp ? omit(props, [\n        'as'\n    ]) : props;\n    return [\n        slot,\n        slotProps\n    ];\n}\n"],"names":["getSlots","state","typeState","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","_state_components","_state_components1","undefined","as","asProp","children","rest","renderFunction","isSlot","SLOT_RENDER_FUNCTION_SYMBOL","render","React","Fragment","shouldOmitAsProp","omit"],"mappings":";;;;+BAsBoBA;;;eAAAA;;;;iEAtBG;sBACF;wBACE;2BACqB;AAmBjC,SAASA,SAASC,KAAK;IAC9B,MAAMC,YAAYD;IAClB,mDAAmD;IACnD,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IACnB,mDAAmD;IACnD,MAAMC,YAAYC,OAAOC,IAAI,CAACL,UAAUM,UAAU;IAClD,KAAK,MAAMC,YAAYJ,UAAU;QAC7B,MAAM,CAACK,MAAMC,MAAM,GAAGC,QAAQV,WAAWO;QACzC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IAC1B;IACA,mDAAmD;IACnD,OAAO;QACHR;QACAC,WAAWA;IACf;AACJ;AACA,SAASQ,QAAQX,KAAK,EAAEQ,QAAQ;IAC5B,IAAII,mBAAmBC;IACvB,MAAMH,QAAQV,KAAK,CAACQ,SAAS;IAC7B,IAAIE,UAAUI,WAAW;QACrB,OAAO;YACH;YACAA;SACH;IACL;IACA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAEC,QAAQ,EAAE,GAAGC,MAAM,GAAGR;IAC1C,MAAMS,iBAAiBC,IAAAA,cAAM,EAACV,SAASA,KAAK,CAACW,sCAA2B,CAAC,GAAGP;IAC5E,MAAML,OAAO,AAAC,CAAA,AAACG,CAAAA,oBAAoBZ,MAAMO,UAAU,AAAD,MAAO,QAAQK,sBAAsB,KAAK,IAAI,KAAK,IAAIA,iBAAiB,CAACJ,SAAS,AAAD,MAAOM,aAAa,8CAA8C;IACrM,mDAAmD;IACnD,OAAOd,MAAMO,UAAU,CAACC,SAAS,KAAK,WAAWQ,UAAW,CAAA,AAACH,CAAAA,qBAAqBb,MAAMO,UAAU,AAAD,MAAO,QAAQM,uBAAuB,KAAK,IAAI,KAAK,IAAIA,kBAAkB,CAACL,SAAS,AAAD,KAAM,QAAQR,MAAMO,UAAU,CAACC,SAAS;IAC5N,IAAIW,kBAAkB,OAAOF,aAAa,YAAY;QAClD,MAAMK,SAASH,kBAAkBF;QACjC,OAAO;YACHM,OAAMC,QAAQ;YACd;gBACIP,UAAUK,OAAOb,MAAMS;YAC3B;SACH;IACL;IACA,MAAMO,mBAAmB,OAAOhB,SAAS,YAAYO;IACrD,mDAAmD;IACnD,MAAMb,YAAYsB,mBAAmBC,IAAAA,UAAI,EAAChB,OAAO;QAC7C;KACH,IAAIA;IACL,OAAO;QACHD;QACAN;KACH;AACL"}
+{"version":3,"sources":["getSlots.js"],"sourcesContent":["import * as React from 'react';\nimport { omit } from '../../utils/omit';\nimport { isSlot } from '../isSlot';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from '../constants';\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 * @deprecated use slot.always or slot.optional combined with assertSlots instead\n *\n * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */ export function getSlots(state) {\n    // eslint-disable-next-line deprecation/deprecation\n    const slots = {};\n    const slotProps = {};\n    const slotNames = Object.keys(state.components);\n    for (const slotName of slotNames){\n        const [slot, props] = getSlot(state, slotName);\n        // eslint-disable-next-line deprecation/deprecation\n        slots[slotName] = slot;\n        slotProps[slotName] = props;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    return {\n        slots,\n        slotProps: slotProps\n    };\n}\nfunction getSlot(state, slotName) {\n    var _state_components, _state_components1;\n    const props = state[slotName];\n    if (props === undefined) {\n        return [\n            null,\n            undefined\n        ];\n    }\n    // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n    const { as: asProp, children, ...rest } = props;\n    const renderFunction = isSlot(props) ? props[SLOT_RENDER_FUNCTION_SYMBOL] : undefined;\n    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];\n    if (renderFunction || typeof children === 'function') {\n        const render = renderFunction || children;\n        return [\n            React.Fragment,\n            {\n                children: render(slot, rest)\n            }\n        ];\n    }\n    const shouldOmitAsProp = typeof slot === 'string' && asProp;\n    const slotProps = shouldOmitAsProp ? omit(props, [\n        'as'\n    ]) : props;\n    return [\n        slot,\n        slotProps\n    ];\n}\n"],"names":["getSlots","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","_state_components","_state_components1","undefined","as","asProp","children","rest","renderFunction","isSlot","SLOT_RENDER_FUNCTION_SYMBOL","render","React","Fragment","shouldOmitAsProp","omit"],"mappings":";;;;+BAsBoBA;;;eAAAA;;;;iEAtBG;sBACF;wBACE;2BACqB;AAmBjC,SAASA,SAASC,KAAK;IAC9B,mDAAmD;IACnD,MAAMC,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IACnB,MAAMC,YAAYC,OAAOC,IAAI,CAACL,MAAMM,UAAU;IAC9C,KAAK,MAAMC,YAAYJ,UAAU;QAC7B,MAAM,CAACK,MAAMC,MAAM,GAAGC,QAAQV,OAAOO;QACrC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IAC1B;IACA,mDAAmD;IACnD,OAAO;QACHR;QACAC,WAAWA;IACf;AACJ;AACA,SAASQ,QAAQV,KAAK,EAAEO,QAAQ;IAC5B,IAAII,mBAAmBC;IACvB,MAAMH,QAAQT,KAAK,CAACO,SAAS;IAC7B,IAAIE,UAAUI,WAAW;QACrB,OAAO;YACH;YACAA;SACH;IACL;IACA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAEC,QAAQ,EAAE,GAAGC,MAAM,GAAGR;IAC1C,MAAMS,iBAAiBC,IAAAA,cAAM,EAACV,SAASA,KAAK,CAACW,sCAA2B,CAAC,GAAGP;IAC5E,MAAML,OAAO,AAAC,CAAA,AAACG,CAAAA,oBAAoBX,MAAMM,UAAU,AAAD,MAAO,QAAQK,sBAAsB,KAAK,IAAI,KAAK,IAAIA,iBAAiB,CAACJ,SAAS,AAAD,MAAOM,aAAa,OAAOb,MAAMM,UAAU,CAACC,SAAS,KAAK,WAAWQ,UAAW,CAAA,AAACH,CAAAA,qBAAqBZ,MAAMM,UAAU,AAAD,MAAO,QAAQM,uBAAuB,KAAK,IAAI,KAAK,IAAIA,kBAAkB,CAACL,SAAS,AAAD,KAAM,QAAQP,MAAMM,UAAU,CAACC,SAAS;IACnX,IAAIW,kBAAkB,OAAOF,aAAa,YAAY;QAClD,MAAMK,SAASH,kBAAkBF;QACjC,OAAO;YACHM,OAAMC,QAAQ;YACd;gBACIP,UAAUK,OAAOb,MAAMS;YAC3B;SACH;IACL;IACA,MAAMO,mBAAmB,OAAOhB,SAAS,YAAYO;IACrD,MAAMb,YAAYsB,mBAAmBC,IAAAA,UAAI,EAAChB,OAAO;QAC7C;KACH,IAAIA;IACL,OAAO;QACHD;QACAN;KACH;AACL"}

package/lib-commonjs/compose/deprecated/getSlotsNext.js

@@ -11,15 +11,13 @@ Object.defineProperty(exports, "getSlotsNext", {
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 function getSlotsNext(state) {
-    const typedState = state;
     // eslint-disable-next-line deprecation/deprecation
     const slots = {};
     const slotProps = {};
-    // eslint-disable-next-line deprecation/deprecation
-    const slotNames = Object.keys(typedState.components);
+    const slotNames = Object.keys(state.components);
     for (const slotName of slotNames){
         // eslint-disable-next-line deprecation/deprecation
-        const [slot, props] = getSlotNext(typedState, slotName);
+        const [slot, props] = getSlotNext(state, slotName);
         // eslint-disable-next-line deprecation/deprecation
         slots[slotName] = slot;
         slotProps[slotName] = props;
@@ -43,11 +41,8 @@ function getSlotsNext(state) {
     }
     // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)
     const { as: asProp, ...propsWithoutAs } = props;
-    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation
-    // eslint-disable-next-line deprecation/deprecation
-    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
+    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];
     const shouldOmitAsProp = typeof slot === 'string' && asProp;
-    // eslint-disable-next-line deprecation/deprecation
     const slotProps = shouldOmitAsProp ? propsWithoutAs : props;
     return [
         slot,

package/lib-commonjs/compose/deprecated/getSlotsNext.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getSlotsNext.js"],"sourcesContent":["import * as React from 'react';\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n *\n * @internal\n * This is an internal temporary method, this method will cease to exist eventually!\n *\n * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️\n *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */ export function getSlotsNext(state) {\n    const typedState = state;\n    // eslint-disable-next-line deprecation/deprecation\n    const slots = {};\n    const slotProps = {};\n    // eslint-disable-next-line deprecation/deprecation\n    const slotNames = Object.keys(typedState.components);\n    for (const slotName of slotNames){\n        // eslint-disable-next-line deprecation/deprecation\n        const [slot, props] = getSlotNext(typedState, slotName);\n        // eslint-disable-next-line deprecation/deprecation\n        slots[slotName] = slot;\n        slotProps[slotName] = props;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    return {\n        slots,\n        slotProps: slotProps\n    };\n}\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */ function getSlotNext(state, slotName) {\n    var _state_components, _state_components1;\n    const props = state[slotName];\n    if (props === undefined) {\n        return [\n            null,\n            undefined\n        ];\n    }\n    // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n    const { as: asProp, ...propsWithoutAs } = props;\n    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || // eslint-disable-line deprecation/deprecation\n    // eslint-disable-next-line deprecation/deprecation\n    typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];\n    const shouldOmitAsProp = typeof slot === 'string' && asProp;\n    // eslint-disable-next-line deprecation/deprecation\n    const slotProps = shouldOmitAsProp ? propsWithoutAs : props;\n    return [\n        slot,\n        slotProps\n    ];\n}\n"],"names":["getSlotsNext","state","typedState","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","_state_components","_state_components1","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"mappings":";;;;+BAUoBA;;;eAAAA;;;;iEAVG;AAUZ,SAASA,aAAaC,KAAK;IAClC,MAAMC,aAAaD;IACnB,mDAAmD;IACnD,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IACnB,mDAAmD;IACnD,MAAMC,YAAYC,OAAOC,IAAI,CAACL,WAAWM,UAAU;IACnD,KAAK,MAAMC,YAAYJ,UAAU;QAC7B,mDAAmD;QACnD,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,YAAYO;QAC9C,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IAC1B;IACA,mDAAmD;IACnD,OAAO;QACHR;QACAC,WAAWA;IACf;AACJ;AACA;;CAEC,GAAG,SAASQ,YAAYX,KAAK,EAAEQ,QAAQ;IACpC,IAAII,mBAAmBC;IACvB,MAAMH,QAAQV,KAAK,CAACQ,SAAS;IAC7B,IAAIE,UAAUI,WAAW;QACrB,OAAO;YACH;YACAA;SACH;IACL;IACA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAE,GAAGC,gBAAgB,GAAGP;IAC1C,MAAMD,OAAO,AAAC,CAAA,AAACG,CAAAA,oBAAoBZ,MAAMO,UAAU,AAAD,MAAO,QAAQK,sBAAsB,KAAK,IAAI,KAAK,IAAIA,iBAAiB,CAACJ,SAAS,AAAD,MAAOM,aAAa,8CAA8C;IACrM,mDAAmD;IACnD,OAAOd,MAAMO,UAAU,CAACC,SAAS,KAAK,WAAWQ,UAAW,CAAA,AAACH,CAAAA,qBAAqBb,MAAMO,UAAU,AAAD,MAAO,QAAQM,uBAAuB,KAAK,IAAI,KAAK,IAAIA,kBAAkB,CAACL,SAAS,AAAD,KAAM,QAAQR,MAAMO,UAAU,CAACC,SAAS;IAC5N,MAAMU,mBAAmB,OAAOT,SAAS,YAAYO;IACrD,mDAAmD;IACnD,MAAMb,YAAYe,mBAAmBD,iBAAiBP;IACtD,OAAO;QACHD;QACAN;KACH;AACL"}
+{"version":3,"sources":["getSlotsNext.js"],"sourcesContent":["import * as React from 'react';\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n *\n * @internal\n * This is an internal temporary method, this method will cease to exist eventually!\n *\n * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️\n *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */ export function getSlotsNext(state) {\n    // eslint-disable-next-line deprecation/deprecation\n    const slots = {};\n    const slotProps = {};\n    const slotNames = Object.keys(state.components);\n    for (const slotName of slotNames){\n        // eslint-disable-next-line deprecation/deprecation\n        const [slot, props] = getSlotNext(state, slotName);\n        // eslint-disable-next-line deprecation/deprecation\n        slots[slotName] = slot;\n        slotProps[slotName] = props;\n    }\n    // eslint-disable-next-line deprecation/deprecation\n    return {\n        slots,\n        slotProps: slotProps\n    };\n}\n/**\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */ function getSlotNext(state, slotName) {\n    var _state_components, _state_components1;\n    const props = state[slotName];\n    if (props === undefined) {\n        return [\n            null,\n            undefined\n        ];\n    }\n    // TS Error: Property 'as' does not exist on type 'UnknownSlotProps | undefined'.ts(2339)\n    const { as: asProp, ...propsWithoutAs } = props;\n    const slot = ((_state_components = state.components) === null || _state_components === void 0 ? void 0 : _state_components[slotName]) === undefined || typeof state.components[slotName] === 'string' ? asProp || ((_state_components1 = state.components) === null || _state_components1 === void 0 ? void 0 : _state_components1[slotName]) || 'div' : state.components[slotName];\n    const shouldOmitAsProp = typeof slot === 'string' && asProp;\n    const slotProps = shouldOmitAsProp ? propsWithoutAs : props;\n    return [\n        slot,\n        slotProps\n    ];\n}\n"],"names":["getSlotsNext","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","_state_components","_state_components1","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"mappings":";;;;+BAUoBA;;;eAAAA;;;;iEAVG;AAUZ,SAASA,aAAaC,KAAK;IAClC,mDAAmD;IACnD,MAAMC,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IACnB,MAAMC,YAAYC,OAAOC,IAAI,CAACL,MAAMM,UAAU;IAC9C,KAAK,MAAMC,YAAYJ,UAAU;QAC7B,mDAAmD;QACnD,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,OAAOO;QACzC,mDAAmD;QACnDN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IAC1B;IACA,mDAAmD;IACnD,OAAO;QACHR;QACAC,WAAWA;IACf;AACJ;AACA;;CAEC,GAAG,SAASQ,YAAYV,KAAK,EAAEO,QAAQ;IACpC,IAAII,mBAAmBC;IACvB,MAAMH,QAAQT,KAAK,CAACO,SAAS;IAC7B,IAAIE,UAAUI,WAAW;QACrB,OAAO;YACH;YACAA;SACH;IACL;IACA,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,MAAM,EAAE,GAAGC,gBAAgB,GAAGP;IAC1C,MAAMD,OAAO,AAAC,CAAA,AAACG,CAAAA,oBAAoBX,MAAMM,UAAU,AAAD,MAAO,QAAQK,sBAAsB,KAAK,IAAI,KAAK,IAAIA,iBAAiB,CAACJ,SAAS,AAAD,MAAOM,aAAa,OAAOb,MAAMM,UAAU,CAACC,SAAS,KAAK,WAAWQ,UAAW,CAAA,AAACH,CAAAA,qBAAqBZ,MAAMM,UAAU,AAAD,MAAO,QAAQM,uBAAuB,KAAK,IAAI,KAAK,IAAIA,kBAAkB,CAACL,SAAS,AAAD,KAAM,QAAQP,MAAMM,UAAU,CAACC,SAAS;IACnX,MAAMU,mBAAmB,OAAOT,SAAS,YAAYO;IACrD,MAAMb,YAAYe,mBAAmBD,iBAAiBP;IACtD,OAAO;QACHD;QACAN;KACH;AACL"}

package/lib-commonjs/compose/deprecated/resolveShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["resolveShorthand.js"],"sourcesContent":["import * as slot from '../slot';\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 *\n * @deprecated use slot.always, slot.optional, slot.resolveShorthand combined with assertSlots instead\n */ // eslint-disable-next-line deprecation/deprecation\nexport const resolveShorthand = (value, options)=>slot.optional(value, {\n        ...options,\n        renderByDefault: options === null || options === void 0 ? void 0 : options.required,\n        // elementType as undefined is the way to identify between a slot and a resolveShorthand call\n        // in the case elementType is undefined assertSlots will fail, ensuring it'll only work with slot method.\n        elementType: undefined\n    });\n"],"names":["resolveShorthand","value","options","slot","optional","renderByDefault","required","elementType","undefined"],"mappings":";;;;+BAUaA;;;eAAAA;;;;gEAVS;AAUf,MAAMA,mBAAmB,CAACC,OAAOC,UAAUC,MAAKC,QAAQ,CAACH,OAAO;QAC/D,GAAGC,OAAO;QACVG,iBAAiBH,YAAY,QAAQA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQI,QAAQ;QACnF,6FAA6F;QAC7F,yGAAyG;QACzGC,aAAaC;IACjB"}
+{"version":3,"sources":["resolveShorthand.js"],"sourcesContent":["import * as slot from '../slot';\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 *\n * @deprecated use slot.always or slot.optional combined with assertSlots instead\n */ // eslint-disable-next-line deprecation/deprecation\nexport const resolveShorthand = (value, options)=>slot.optional(value, {\n        ...options,\n        renderByDefault: options === null || options === void 0 ? void 0 : options.required,\n        // elementType as undefined is the way to identify between a slot and a resolveShorthand call\n        // in the case elementType is undefined assertSlots will fail, ensuring it'll only work with slot method.\n        elementType: undefined\n    });\n"],"names":["resolveShorthand","value","options","slot","optional","renderByDefault","required","elementType","undefined"],"mappings":";;;;+BAUaA;;;eAAAA;;;;gEAVS;AAUf,MAAMA,mBAAmB,CAACC,OAAOC,UAAUC,MAAKC,QAAQ,CAACH,OAAO;QAC/D,GAAGC,OAAO;QACVG,iBAAiBH,YAAY,QAAQA,YAAY,KAAK,IAAI,KAAK,IAAIA,QAAQI,QAAQ;QACnF,6FAA6F;QAC7F,yGAAyG;QACzGC,aAAaC;IACjB"}

package/lib-commonjs/compose/slot.js

@@ -48,7 +48,7 @@ function optional(value, options) {
     return always(value, options);
 }
 function resolveShorthand(value) {
-    if (typeof value === 'string' || typeof value === 'number' || isIterable(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any
     /*#__PURE__*/ _react.isValidElement(value)) {
         return {
             children: value
@@ -64,4 +64,3 @@ Slot shorthands can be strings, numbers, arrays or JSX elements`);
     }
     return value;
 }
-const isIterable = (value)=>typeof value === 'object' && value !== null && Symbol.iterator in value;

package/lib-commonjs/compose/slot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["slot.js"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.\n */ export function always(value, options) {\n    const { defaultProps, elementType } = options;\n    const props = resolveShorthand(value);\n    /**\n   * Casting is required here as SlotComponentType is a function, not an object.\n   * Although SlotComponentType has a function signature, it is still just an object.\n   * This is required to make a slot callable (JSX compatible), this is the exact same approach\n   * that is used on `@types/react` components\n   */ const propsWithMetadata = {\n        ...defaultProps,\n        ...props,\n        [SLOT_ELEMENT_TYPE_SYMBOL]: elementType\n    };\n    if (props && typeof props.children === 'function') {\n        propsWithMetadata[SLOT_RENDER_FUNCTION_SYMBOL] = props.children;\n        propsWithMetadata.children = defaultProps === null || defaultProps === void 0 ? void 0 : defaultProps.children;\n    }\n    return propsWithMetadata;\n}\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided\n * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.\n * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`\n * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object\n * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content\n * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`\n */ export function optional(value, options) {\n    if (value === null || value === undefined && !options.renderByDefault) {\n        return undefined;\n    }\n    return always(value, options);\n}\n/**\n * Helper function that converts a slot shorthand or properties to a slot properties object\n * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object\n * @param value - the value of the slot, it can be a slot shorthand or a slot properties object\n */ export function resolveShorthand(value) {\n    if (typeof value === 'string' || typeof value === 'number' || isIterable(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    React.isValidElement(value)) {\n        return {\n            children: value\n        };\n    }\n    if (value && typeof value !== 'object' && process.env.NODE_ENV !== 'production') {\n        // TODO: would be nice to have a link to slot documentation in this error message\n        // eslint-disable-next-line no-console\n        console.error(`@fluentui/react-utilities [slot.${resolveShorthand.name}]:\nA slot got an invalid value \"${value}\" (${typeof value}).\nA valid value for a slot is a slot shorthand or slot properties object.\nSlot shorthands can be strings, numbers, arrays or JSX elements`);\n    }\n    return value;\n}\nconst isIterable = (value)=>typeof value === 'object' && value !== null && Symbol.iterator in value;\n"],"names":["always","optional","resolveShorthand","value","options","defaultProps","elementType","props","propsWithMetadata","SLOT_ELEMENT_TYPE_SYMBOL","children","SLOT_RENDER_FUNCTION_SYMBOL","undefined","renderByDefault","isIterable","React","isValidElement","process","env","NODE_ENV","console","error","name","Symbol","iterator"],"mappings":";;;;;;;;;;;IASoBA,MAAM;eAANA;;IA+BAC,QAAQ;eAARA;;IAUAC,gBAAgB;eAAhBA;;;;iEAlDG;2BAC+C;AAQ3D,SAASF,OAAOG,KAAK,EAAEC,OAAO;IACrC,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGF;IACtC,MAAMG,QAAQL,iBAAiBC;IAC/B;;;;;GAKD,GAAG,MAAMK,oBAAoB;QACxB,GAAGH,YAAY;QACf,GAAGE,KAAK;QACR,CAACE,mCAAwB,CAAC,EAAEH;IAChC;IACA,IAAIC,SAAS,OAAOA,MAAMG,QAAQ,KAAK,YAAY;QAC/CF,iBAAiB,CAACG,sCAA2B,CAAC,GAAGJ,MAAMG,QAAQ;QAC/DF,kBAAkBE,QAAQ,GAAGL,iBAAiB,QAAQA,iBAAiB,KAAK,IAAI,KAAK,IAAIA,aAAaK,QAAQ;IAClH;IACA,OAAOF;AACX;AAaW,SAASP,SAASE,KAAK,EAAEC,OAAO;IACvC,IAAID,UAAU,QAAQA,UAAUS,aAAa,CAACR,QAAQS,eAAe,EAAE;QACnE,OAAOD;IACX;IACA,OAAOZ,OAAOG,OAAOC;AACzB;AAKW,SAASF,iBAAiBC,KAAK;IACtC,IAAI,OAAOA,UAAU,YAAY,OAAOA,UAAU,YAAYW,WAAWX,UAAU,8DAA8D;kBACjJY,OAAMC,cAAc,CAACb,QAAQ;QACzB,OAAO;YACHO,UAAUP;QACd;IACJ;IACA,IAAIA,SAAS,OAAOA,UAAU,YAAYc,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QAC7E,iFAAiF;QACjF,sCAAsC;QACtCC,QAAQC,KAAK,CAAC,CAAC,gCAAgC,EAAEnB,iBAAiBoB,IAAI,CAAC;6BAClD,EAAEnB,MAAM,GAAG,EAAE,OAAOA,MAAM;;+DAEQ,CAAC;IAC5D;IACA,OAAOA;AACX;AACA,MAAMW,aAAa,CAACX,QAAQ,OAAOA,UAAU,YAAYA,UAAU,QAAQoB,OAAOC,QAAQ,IAAIrB"}
+{"version":3,"sources":["slot.js"],"sourcesContent":["import * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided.\n */ export function always(value, options) {\n    const { defaultProps, elementType } = options;\n    const props = resolveShorthand(value);\n    /**\n   * Casting is required here as SlotComponentType is a function, not an object.\n   * Although SlotComponentType has a function signature, it is still just an object.\n   * This is required to make a slot callable (JSX compatible), this is the exact same approach\n   * that is used on `@types/react` components\n   */ const propsWithMetadata = {\n        ...defaultProps,\n        ...props,\n        [SLOT_ELEMENT_TYPE_SYMBOL]: elementType\n    };\n    if (props && typeof props.children === 'function') {\n        propsWithMetadata[SLOT_RENDER_FUNCTION_SYMBOL] = props.children;\n        propsWithMetadata.children = defaultProps === null || defaultProps === void 0 ? void 0 : defaultProps.children;\n    }\n    return propsWithMetadata;\n}\n/**\n * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)\n * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties\n * @param options - values you can pass to alter the signature of a slot, those values are:\n *\n * * `elementType` - the base element type of a slot, defaults to `'div'`\n * * `defaultProps` - similar to a React component declaration, you can provide a slot default properties to be merged with the shorthand/properties provided\n * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.\n * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`\n * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object\n * with the values provided by `options.defaultProps` (or `{}`). This is useful for cases such as providing a default content\n * in case no shorthand is provided, like the case of the `expandIcon` slot for the `AccordionHeader`\n */ export function optional(value, options) {\n    if (value === null || value === undefined && !options.renderByDefault) {\n        return undefined;\n    }\n    return always(value, options);\n}\n/**\n * Helper function that converts a slot shorthand or properties to a slot properties object\n * The main difference between this function and `slot` is that this function does not return the metadata required for a slot to be considered a properly renderable slot, it only converts the value to a slot properties object\n * @param value - the value of the slot, it can be a slot shorthand or a slot properties object\n */ export function resolveShorthand(value) {\n    if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    React.isValidElement(value)) {\n        return {\n            children: value\n        };\n    }\n    if (value && typeof value !== 'object' && process.env.NODE_ENV !== 'production') {\n        // TODO: would be nice to have a link to slot documentation in this error message\n        // eslint-disable-next-line no-console\n        console.error(`@fluentui/react-utilities [slot.${resolveShorthand.name}]:\nA slot got an invalid value \"${value}\" (${typeof value}).\nA valid value for a slot is a slot shorthand or slot properties object.\nSlot shorthands can be strings, numbers, arrays or JSX elements`);\n    }\n    return value;\n}\n"],"names":["always","optional","resolveShorthand","value","options","defaultProps","elementType","props","propsWithMetadata","SLOT_ELEMENT_TYPE_SYMBOL","children","SLOT_RENDER_FUNCTION_SYMBOL","undefined","renderByDefault","Array","isArray","React","isValidElement","process","env","NODE_ENV","console","error","name"],"mappings":";;;;;;;;;;;IASoBA,MAAM;eAANA;;IA+BAC,QAAQ;eAARA;;IAUAC,gBAAgB;eAAhBA;;;;iEAlDG;2BAC+C;AAQ3D,SAASF,OAAOG,KAAK,EAAEC,OAAO;IACrC,MAAM,EAAEC,YAAY,EAAEC,WAAW,EAAE,GAAGF;IACtC,MAAMG,QAAQL,iBAAiBC;IAC/B;;;;;GAKD,GAAG,MAAMK,oBAAoB;QACxB,GAAGH,YAAY;QACf,GAAGE,KAAK;QACR,CAACE,mCAAwB,CAAC,EAAEH;IAChC;IACA,IAAIC,SAAS,OAAOA,MAAMG,QAAQ,KAAK,YAAY;QAC/CF,iBAAiB,CAACG,sCAA2B,CAAC,GAAGJ,MAAMG,QAAQ;QAC/DF,kBAAkBE,QAAQ,GAAGL,iBAAiB,QAAQA,iBAAiB,KAAK,IAAI,KAAK,IAAIA,aAAaK,QAAQ;IAClH;IACA,OAAOF;AACX;AAaW,SAASP,SAASE,KAAK,EAAEC,OAAO;IACvC,IAAID,UAAU,QAAQA,UAAUS,aAAa,CAACR,QAAQS,eAAe,EAAE;QACnE,OAAOD;IACX;IACA,OAAOZ,OAAOG,OAAOC;AACzB;AAKW,SAASF,iBAAiBC,KAAK;IACtC,IAAI,OAAOA,UAAU,YAAY,OAAOA,UAAU,YAAYW,MAAMC,OAAO,CAACZ,UAAU,8DAA8D;kBACpJa,OAAMC,cAAc,CAACd,QAAQ;QACzB,OAAO;YACHO,UAAUP;QACd;IACJ;IACA,IAAIA,SAAS,OAAOA,UAAU,YAAYe,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;QAC7E,iFAAiF;QACjF,sCAAsC;QACtCC,QAAQC,KAAK,CAAC,CAAC,gCAAgC,EAAEpB,iBAAiBqB,IAAI,CAAC;6BAClD,EAAEpB,MAAM,GAAG,EAAE,OAAOA,MAAM;;+DAEQ,CAAC;IAC5D;IACA,OAAOA;AACX"}

package/lib-commonjs/utils/types.js

@@ -1,6 +1,24 @@
+/**
+ * Helper type that works similar to Omit,
+ * but when modifying an union type it will distribute the omission to all the union members.
+ *
+ * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information
+ */ // Traditional Omit is basically equivalent to => Pick<T, Exclude<keyof T, K>>
+//
+// let's say we have Omit<{ a: string } | { b: string }, 'a'>
+// equivalent to: Pick<{ a: string } | { b: string }, Exclude<keyof ({ a: string } | { b: string }), 'a'>>
+// The expected result would be {} | { b: string }, the omission of 'a' from all the union members,
+// but keyof ({ a: string } | { b: string }) is never as they don't share common keys
+// so  Exclude<never, 'a'> is never,
+// and Pick<{ a: string } | { b: string }, never> is {}.
+//
+// With DistributiveOmit on the other hand it becomes like this:
+// DistributiveOmit<{ a: string } | { b: string }, 'a'>
+// equivalent to: Omit<{ a: string }, 'a'> | Omit<{ b: string }, 'a'>
+// Since every single Omit clause in this case is being applied to a single union member there's no conflicts on keyof evaluation and in the second clause Omit<{ b: string }, 'a'> becomes { b: string },
+// so the result is {} | { b: string }, as expected.
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 "use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
-const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

package/lib-commonjs/utils/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["types.js"],"sourcesContent":["/**\n * Helper type that works similar to Omit,\n * but when modifying an union type it will distribute the omission to all the union members.\n *\n * See [distributive conditional types](https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types) for more information\n */ // Traditional Omit is basically equivalent to => Pick<T, Exclude<keyof T, K>>\n//\n// let's say we have Omit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Pick<{ a: string } | { b: string }, Exclude<keyof ({ a: string } | { b: string }), 'a'>>\n// The expected result would be {} | { b: string }, the omission of 'a' from all the union members,\n// but keyof ({ a: string } | { b: string }) is never as they don't share common keys\n// so  Exclude<never, 'a'> is never,\n// and Pick<{ a: string } | { b: string }, never> is {}.\n//\n// With DistributiveOmit on the other hand it becomes like this:\n// DistributiveOmit<{ a: string } | { b: string }, 'a'>\n// equivalent to: Omit<{ a: string }, 'a'> | Omit<{ b: string }, 'a'>\n// Since every single Omit clause in this case is being applied to a single union member there's no conflicts on keyof evaluation and in the second clause Omit<{ b: string }, 'a'> becomes { b: string },\n// so the result is {} | { b: string }, as expected.\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport { };\n"],"names":[],"mappings":"AAAA;;;;;CAKC,GAAG,8EAA8E;AAClF,EAAE;AACF,6DAA6D;AAC7D,0GAA0G;AAC1G,mGAAmG;AACnG,qFAAqF;AACrF,oCAAoC;AACpC,wDAAwD;AACxD,EAAE;AACF,gEAAgE;AAChE,uDAAuD;AACvD,qEAAqE;AACrE,0MAA0M;AAC1M,oDAAoD;AACpD,8DAA8D"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-utilities",
-  "version": "0.0.0-nightly-20240607-1142.1",
+  "version": "0.0.0-nightly-20240610-0407.1",
   "description": "A set of general React-specific utilities.",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -31,8 +31,8 @@
     "@fluentui/scripts-tasks": "*"
   },
   "dependencies": {
-    "@fluentui/keyboard-keys": "0.0.0-nightly-20240607-1142.1",
-    "@fluentui/react-shared-contexts": "0.0.0-nightly-20240607-1142.1",
+    "@fluentui/keyboard-keys": "0.0.0-nightly-20240610-0407.1",
+    "@fluentui/react-shared-contexts": "0.0.0-nightly-20240610-0407.1",
     "@swc/helpers": "^0.5.1"
   },
   "peerDependencies": {