@fluentui/react-utilities 9.26.2 → 9.26.3

package/CHANGELOG.md

@@ -1,12 +1,21 @@
 # Change Log - @fluentui/react-utilities
 
-This log was last generated on Wed, 25 Feb 2026 13:28:23 GMT and should not be manually modified.
+This log was last generated on Thu, 23 Apr 2026 11:59:37 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.26.3](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.26.3)
+
+Thu, 23 Apr 2026 11:59:37 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.26.2..@fluentui/react-utilities_v9.26.3)
+
+### Patches
+
+- fix: add focusgroupstart property to baseElementProperties ([PR #36020](https://github.com/microsoft/fluentui/pull/36020) by dmytrokirpa@microsoft.com)
+
 ## [9.26.2](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.26.2)
 
-Wed, 25 Feb 2026 13:28:23 GMT 
+Wed, 25 Feb 2026 13:32:28 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.26.1..@fluentui/react-utilities_v9.26.2)
 
 ### Patches

package/dist/index.d.ts

@@ -11,8 +11,9 @@ import * as React_2 from 'react';
 declare function always<Props extends UnknownSlotProps>(value: Props | SlotShorthandValue | undefined, options: SlotOptions<Props>): SlotComponentType<Props>;
 
 /**
- * @internal
  * resolve the trigger props to the children, either by calling the render function, or cloning with the new props.
+ *
+ * @internal
  */
 export declare function applyTriggerPropsToChildren<TriggerChildProps>(children: TriggerProps<TriggerChildProps>['children'], triggerChildProps: TriggerChildProps): React_2.ReactElement | null;
 
@@ -29,22 +30,22 @@ declare type AsIntrinsicElement<As extends JSXIntrinsicElementKeys> = {
 };
 
 /**
- * @internal
  * Assertion method to ensure state slots properties are properly declared.
  * A properly declared slot must be declared by using the `slot` method.
  *
+ * @internal
  * @example
  * ```tsx
  * export const renderInput_unstable  = (state: InputState): JSXElement => {
- assertSlots<InputSlots>(state);
- return (
- <state.root>
- {state.contentBefore && <state.contentBefore />}
- <state.input />
- {state.contentAfter && <state.contentAfter />}
- </state.root>
- );
- };
+ *     assertSlots<InputSlots>(state);
+ *     return (
+ *       <state.root>
+ *         {state.contentBefore && <state.contentBefore />}
+ *         <state.input />
+ *         {state.contentAfter && <state.contentAfter />}
+ *       </state.root>
+ *     );
+ *   };
  * ```
  */
 export declare function assertSlots<Slots extends SlotPropsRecord>(state: unknown): asserts state is SlotComponents<Slots>;
@@ -55,9 +56,9 @@ export declare function assertSlots<Slots extends SlotPropsRecord>(state: unknow
 export declare function canUseDOM(): boolean;
 
 /**
- * @internal
  * Clamps `value` to a number between the min and max.
  *
+ * @internal
  * @param value - the value to be clamped
  * @param min - the lowest valid value
  * @param max - the highest valid value
@@ -65,8 +66,9 @@ 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**
+ *
+ * @internal
  */
 declare interface ComponentClass<P = {}, S = React_2.ComponentState> extends React_2.StaticLifecycle<P, S> {
     new (props: P): React_2.Component<P, S>;
@@ -96,12 +98,13 @@ export declare type ComponentState<Slots extends SlotPropsRecord> = {
 };
 
 /**
- * @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.
+ *
+ * @internal
  */
 declare type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
 
@@ -179,7 +182,6 @@ declare interface ExoticComponent<P> {
 export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null | undefined>;
 
 /**
- * @internal
  * Allows a component to be tagged as a FluentUI trigger component.
  *
  * Triggers are special-case components: they attach event listeners and other props on their child,
@@ -191,6 +193,8 @@ export declare type ExtractSlotProps<S> = Exclude<S, SlotShorthandValue | null |
  *
  * MyComponent.isFluentTriggerComponent = true; // MUST also set this to true
  * ```
+ *
+ * @internal
  */
 export declare type FluentTriggerComponent = {
     isFluentTriggerComponent?: boolean;
@@ -208,8 +212,6 @@ export declare type FluentTriggerComponent = {
 export declare type ForwardRefComponent<Props> = NamedExoticComponent<Props & 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}
  *
@@ -222,6 +224,8 @@ export declare type ForwardRefComponent<Props> = NamedExoticComponent<Props & Re
  * that will work for both cases.
  *
  * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
  */
 declare interface FunctionComponent<P> {
     (props: P): any;
@@ -307,8 +311,9 @@ export declare const getPartitionedNativeProps: <Props extends Pick<React_2.HTML
 export declare function getReactElementRef<T>(element: React_2.ReactElement | null | undefined): React_2.Ref<T> | undefined;
 
 /**
- * @internal
  * Finds and swaps a provided key for it's right to left format.
+ *
+ * @internal
  */
 export declare const getRTLSafeKey: (key: string, dir: "ltr" | "rtl") => string;
 
@@ -356,11 +361,11 @@ export declare function getSlots<R extends SlotPropsRecord>(state: unknown): {
 /**
  * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma
  *
- * @internal
  * This is an internal temporary method, this method will cease to exist eventually!
  *
  * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️
  *
+ * @internal
  * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */
 export declare function getSlotsNext<R extends SlotPropsRecord>(state: unknown): {
@@ -369,7 +374,6 @@ export declare function getSlotsNext<R extends SlotPropsRecord>(state: unknown):
 };
 
 /**
- * @internal
  * Gets the trigger element of a FluentTriggerComponent (such as Tooltip or MenuTrigger).
  *
  * In the case where the immediate child is itself a FluentTriggerComponent and/or React Fragment,
@@ -389,6 +393,8 @@ export declare function getSlotsNext<R extends SlotPropsRecord>(state: unknown):
  *
  * In the case where the immediate child is not a valid element,
  * null is returned
+ *
+ * @internal
  */
 export declare function getTriggerChild<TriggerChildProps>(children: TriggerProps<TriggerChildProps>['children']): (React_2.ReactElement<Partial<TriggerChildProps>> & {
     ref?: React_2.Ref<any>;
@@ -417,9 +423,10 @@ export declare type InferredElementRefType<Props> = ObscureEventName extends key
 declare type IntrinsicElementProps<Type extends JSXIntrinsicElementKeys> = Type extends EmptyIntrinsicElements ? PropsWithoutChildren<React_2.PropsWithRef<JSXIntrinsicElement<Type>>> : React_2.PropsWithRef<JSXIntrinsicElement<Type>>;
 
 /**
- * @internal
  * Checks if a given element is a FluentUI trigger (e.g. `MenuTrigger` or `Tooltip`).
  * See the {@link FluentTriggerComponent} type for more info.
+ *
+ * @internal
  */
 export declare function isFluentTrigger(element: React_2.ReactElement): element is React_2.ReactElement<TriggerProps>;
 
@@ -446,8 +453,9 @@ export declare function isHTMLElement<ConstructorName extends HTMLElementConstru
 }): element is InstanceType<(typeof globalThis)[ConstructorName]>;
 
 /**
- * @internal
  * Checks that the element has default behaviour from user input on click or 'Enter'/'Space' keys
+ *
+ * @internal
  */
 export declare function isInteractiveHTMLElement(element: unknown): boolean;
 
@@ -562,7 +570,6 @@ export declare type JSXIntrinsicElement<Element extends JSXIntrinsicElementKeys>
 export declare type JSXIntrinsicElementKeys = Exclude<React_2.ElementType, React_2.ComponentType>;
 
 /**
- * @internal
  * Combine two event callbacks into a single callback function that calls each one in order.
  *
  * Usage example:
@@ -579,6 +586,7 @@ export declare type JSXIntrinsicElementKeys = Exclude<React_2.ElementType, React
  *
  * If you need a callback that is stable between renders, wrap the result in {@link useEventCallback}.
  *
+ * @internal
  * @param callback1 - The first callback to be called, or undefined
  * @param callback2 - The second callback to be called, or undefined
  *
@@ -683,22 +691,19 @@ 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**
  *
+ * @internal
  */
 declare type ReactNode = any;
 
 export declare type ReactTouchOrMouseEvent = React_2.MouseEvent | React_2.TouchEvent;
 
 /**
- * @internal
- *
  * This type is used to determine if the current version of React is 18+ or not.
  *
  * It checks if the `React.ReactNode` has `{}` it its type.
@@ -707,6 +712,8 @@ export declare type ReactTouchOrMouseEvent = React_2.MouseEvent | React_2.TouchE
  * This is useful for ensuring compatibility with different versions of React.
  *
  * **THIS TYPE IS INTERNAL AND SHOULD NEVER BE EXPOSED**
+ *
+ * @internal
  */
 declare type ReactVersionDependent<Modern, Legacy> = {} extends React_2.ReactNode ? Legacy : Modern;
 
@@ -738,8 +745,9 @@ export declare interface RefAttributes<T> extends React_2.Attributes {
 export declare type RefObjectFunction<T> = React_2.RefObject<T | null> & ((value: T | null) => void);
 
 /**
- * @internal
  * If type T includes `null`, remove it and add `undefined` instead.
+ *
+ * @internal
  */
 declare type ReplaceNullWithUndefined<T> = T extends null ? Exclude<T, null> | undefined : T;
 
@@ -863,20 +871,23 @@ declare namespace slot {
 export { slot }
 
 /**
- * @internal
  * Internal cache of the original className prop for the slot, before being modified by the useStyles hook.
+ *
+ * @internal
  */
 export declare const SLOT_CLASS_NAME_PROP_SYMBOL: unique symbol;
 
 /**
- * @internal
  * Internal reference for the render function
+ *
+ * @internal
  */
 export declare const SLOT_ELEMENT_TYPE_SYMBOL: unique symbol;
 
 /**
- * @internal
  * Internal reference for the render function
+ *
+ * @internal
  */
 export declare const SLOT_RENDER_FUNCTION_SYMBOL: unique symbol;
 
@@ -907,8 +918,9 @@ export declare type SlotComponentType<Props> = WithoutSlotRenderFunction<Props>
      */
     [SLOT_ELEMENT_TYPE_SYMBOL]: ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : JSXIntrinsicElementKeys);
     /**
-     * @internal
      * The original className prop for the slot, before being modified by the useStyles hook.
+     *
+     * @internal
      */
     [SLOT_CLASS_NAME_PROP_SYMBOL]?: string;
 };
@@ -979,11 +991,11 @@ export declare type UnknownSlotProps = Pick<React_2.HTMLAttributes<HTMLElement>,
 };
 
 /**
- * @internal
  * Helper to manage a browser requestAnimationFrame.
  * Ensures that the requestAnimationFrame isn't set multiple times at once and is cleaned up
  * when the component is unloaded.
  *
+ * @internal
  * @returns A pair of [requestAnimationFrame, cancelAnimationFrame] that are stable between renders.
  */
 export declare function useAnimationFrame(): readonly [(fn: FrameRequestCallback) => number, () => void];
@@ -1016,12 +1028,11 @@ declare interface UseApplyScrollbarWidthOptions {
 }
 
 /**
- * @internal
- *
  * A [`useState`](https://reactjs.org/docs/hooks-reference.html#usestate)-like hook
  * to manage a value that could be either `controlled` or `uncontrolled`,
  * such as a checked state or text input string.
  *
+ * @internal
  * @see https://react.dev/learn/sharing-state-between-components#controlled-and-uncontrolled-components for more details on `controlled`/`uncontrolled`
  *
  * @returns an array of the current value and an updater (dispatcher) function.
@@ -1030,7 +1041,6 @@ declare interface UseApplyScrollbarWidthOptions {
  *
  * ❗️❗️ Calls to the dispatcher will only modify the state if the state is `uncontrolled`.
  * Meaning that if a state is `controlled`, calls to the dispatcher do not modify the state.
- *
  */
 export declare const useControllableState: <State>(options: UseControllableStateOptions<State>) => [State, React_2.Dispatch<React_2.SetStateAction<State>>];
 
@@ -1054,7 +1064,6 @@ export declare type UseControllableStateOptions<State> = {
 };
 
 /**
- * @internal
  * https://reactjs.org/docs/hooks-faq.html#how-to-read-an-often-changing-value-from-usecallback
  *
  * Modified `useCallback` that can be used when dependencies change too frequently. Can occur when
@@ -1064,24 +1073,26 @@ export declare type UseControllableStateOptions<State> = {
  * This should not be used often, but can be a useful re-render optimization since the callback is a ref and
  * will not be invalidated between re-renders
  *
+ * @internal
  * @param fn - The callback function that will be used
  */
 export declare const useEventCallback: <Args extends unknown[], Return>(fn: (...args: Args) => Return) => ((...args: Args) => Return);
 
 /**
- * @internal
  * Checks if components was mounted the first time.
  * Supports React concurrent/strict mode by using `useEffect`
  * to track the first mount instead of mutating refs during render.
  *
+ * @internal
  * @example
  * const isFirstMount = useFirstMount();
  */
 export declare function useFirstMount(): boolean;
 
 /**
- * @internal
  * Forces a re-render, similar to `forceUpdate` in class components.
+ *
+ * @internal
  */
 export declare function useForceUpdate(): React_2.DispatchWithoutAction;
 
@@ -1154,14 +1165,16 @@ export declare type UseOnClickOrScrollOutsideOptions = {
 };
 
 /**
- * @internal
  * Utility to perform checks where a click/touch event was made outside a component
+ *
+ * @internal
  */
 export declare const useOnClickOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
 
 /**
- * @internal
  * Utility to perform checks where a click/touch event was made outside a component
+ *
+ * @internal
  */
 export declare const useOnScrollOutside: (options: UseOnClickOrScrollOutsideOptions) => void;
 
@@ -1190,11 +1203,11 @@ declare interface UseScrollbarWidthOptions {
 export declare function useSelection(params: SelectionHookParams): readonly [Set<SelectionItemId>, SelectionMethods];
 
 /**
- * @internal
  * Helper to manage a browser timeout.
  * Ensures that the timeout isn't set multiple times at once and is cleaned up
  * when the component is unloaded.
  *
+ * @internal
  * @returns A pair of [setTimeout, clearTimeout] that are stable between renders.
  */
 export declare function useTimeout(): readonly [(fn: () => void, delay?: number) => number, () => void];
@@ -1207,7 +1220,6 @@ declare type WithoutSlotRenderFunction<Props> = Props extends unknown ? 'childre
 } : 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.
  *
@@ -1215,6 +1227,7 @@ declare type WithoutSlotRenderFunction<Props> = Props extends unknown ? 'childre
  * For React 18 and later, `children` can be any value, as React.ReactNode is a more strict type and does not allow functions anymore.
  * This means that the render functions need to be asserted as `SlotRenderFunction<Props>` for React 18 and later.
  *
+ * @internal
  * @example
  * ```tsx
  * // For React 17 and earlier:

package/lib/compose/assertSlots.js

@@ -1,24 +1,23 @@
-import * as React from 'react';
 import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';
 import { isSlot } from './isSlot';
 import * as slot from './slot';
 /**
- * @internal
  * Assertion method to ensure state slots properties are properly declared.
  * A properly declared slot must be declared by using the `slot` method.
  *
+ * @internal
  * @example
  * ```tsx
  * export const renderInput_unstable  = (state: InputState): JSXElement => {
-    assertSlots<InputSlots>(state);
-    return (
-      <state.root>
-        {state.contentBefore && <state.contentBefore />}
-        <state.input />
-        {state.contentAfter && <state.contentAfter />}
-      </state.root>
-    );
-  };
+ *     assertSlots<InputSlots>(state);
+ *     return (
+ *       <state.root>
+ *         {state.contentBefore && <state.contentBefore />}
+ *         <state.input />
+ *         {state.contentAfter && <state.contentAfter />}
+ *       </state.root>
+ *     );
+ *   };
  * ```
  */ export function assertSlots(state) {
     /**

package/lib/compose/assertSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/compose/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]>> | (null extends Slots[K] ? undefined : never);\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): JSXElement => {\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 @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\n        if (elementType !== typedState.components[slotName]) {\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\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} !== ${\n            typedState.components[slotName] /* eslint-disable-line @typescript-eslint/no-deprecated */\n          }.\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,4DAA4D;QAC5D,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,4DAA4D;oBAC5DG,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,4DAA4D;gBAC5D,IAAIG,gBAAgBR,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACnD,4DAA4D;oBAC5DI,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,EACnBR,WAAWI,UAAU,CAACH,SAAS,CAChC;wGAED,CAAC;gBACH;YACF;QACF;IACF;AACF"}
+{"version":3,"sources":["../src/compose/assertSlots.ts"],"sourcesContent":["import type * as React from 'react';\nimport { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport type { 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]>> | (null extends Slots[K] ? undefined : never);\n};\n\n/**\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 * @internal\n * @example\n * ```tsx\n * export const renderInput_unstable  = (state: InputState): JSXElement => {\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 @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\n        if (elementType !== typedState.components[slotName]) {\n          // eslint-disable-next-line @typescript-eslint/no-deprecated\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} !== ${\n            typedState.components[slotName] /* eslint-disable-line @typescript-eslint/no-deprecated */\n          }.\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":["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":"AACA,SAASA,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,4DAA4D;QAC5D,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,4DAA4D;oBAC5DG,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,4DAA4D;gBAC5D,IAAIG,gBAAgBR,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACnD,4DAA4D;oBAC5DI,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,EACnBR,WAAWI,UAAU,CAACH,SAAS,CAChC;wGAED,CAAC;gBACH;YACF;QACF;IACF;AACF"}

package/lib/compose/constants.js

@@ -1,12 +1,15 @@
 /**
- * @internal
  * Internal reference for the render function
+ *
+ * @internal
  */ export const SLOT_RENDER_FUNCTION_SYMBOL = Symbol.for('fui.slotRenderFunction');
 /**
- * @internal
  * Internal reference for the render function
+ *
+ * @internal
  */ export const SLOT_ELEMENT_TYPE_SYMBOL = Symbol.for('fui.slotElementType');
 /**
- * @internal
  * Internal cache of the original className prop for the slot, before being modified by the useStyles hook.
+ *
+ * @internal
  */ export const SLOT_CLASS_NAME_PROP_SYMBOL = Symbol.for('fui.slotClassNameProp');

package/lib/compose/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/compose/constants.ts"],"sourcesContent":["/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_RENDER_FUNCTION_SYMBOL = Symbol.for('fui.slotRenderFunction');\n/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_ELEMENT_TYPE_SYMBOL = Symbol.for('fui.slotElementType');\n/**\n * @internal\n * Internal cache of the original className prop for the slot, before being modified by the useStyles hook.\n */\nexport const SLOT_CLASS_NAME_PROP_SYMBOL = Symbol.for('fui.slotClassNameProp');\n"],"names":["SLOT_RENDER_FUNCTION_SYMBOL","Symbol","for","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_CLASS_NAME_PROP_SYMBOL"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,8BAA8BC,OAAOC,GAAG,CAAC,0BAA0B;AAChF;;;CAGC,GACD,OAAO,MAAMC,2BAA2BF,OAAOC,GAAG,CAAC,uBAAuB;AAC1E;;;CAGC,GACD,OAAO,MAAME,8BAA8BH,OAAOC,GAAG,CAAC,yBAAyB"}
+{"version":3,"sources":["../src/compose/constants.ts"],"sourcesContent":["/**\n * Internal reference for the render function\n *\n * @internal\n */\nexport const SLOT_RENDER_FUNCTION_SYMBOL = Symbol.for('fui.slotRenderFunction');\n/**\n * Internal reference for the render function\n *\n * @internal\n */\nexport const SLOT_ELEMENT_TYPE_SYMBOL = Symbol.for('fui.slotElementType');\n/**\n * Internal cache of the original className prop for the slot, before being modified by the useStyles hook.\n *\n * @internal\n */\nexport const SLOT_CLASS_NAME_PROP_SYMBOL = Symbol.for('fui.slotClassNameProp');\n"],"names":["SLOT_RENDER_FUNCTION_SYMBOL","Symbol","for","SLOT_ELEMENT_TYPE_SYMBOL","SLOT_CLASS_NAME_PROP_SYMBOL"],"mappings":"AAAA;;;;CAIC,GACD,OAAO,MAAMA,8BAA8BC,OAAOC,GAAG,CAAC,0BAA0B;AAChF;;;;CAIC,GACD,OAAO,MAAMC,2BAA2BF,OAAOC,GAAG,CAAC,uBAAuB;AAC1E;;;;CAIC,GACD,OAAO,MAAME,8BAA8BH,OAAOC,GAAG,CAAC,yBAAyB"}

package/lib/compose/deprecated/getSlotsNext.js

@@ -1,12 +1,11 @@
-import * as React from 'react';
 /**
  * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma
  *
- * @internal
  * This is an internal temporary method, this method will cease to exist eventually!
  *
  * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️
  *
+ * @internal
  * @deprecated use slot.always or slot.optional combined with assertSlots instead
  */ export function getSlotsNext(state) {
     const typedState = state;

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

@@ -1 +1 @@
-{"version":3,"sources":["../src/compose/deprecated/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 @typescript-eslint/no-deprecated\n  slots: Slots<R>;\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  slotProps: ObjectSlotProps<R>;\n} {\n  const typedState = state as ComponentState<R>;\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const slotNames: (keyof R)[] = Object.keys(typedState.components);\n  for (const slotName of slotNames) {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    const [slot, props] = getSlotNext(typedState, slotName);\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    typeof state.components[slotName] === 'string'\n      ? // eslint-disable-next-line @typescript-eslint/no-deprecated\n        asProp || state.components?.[slotName] || 'div'\n      : // eslint-disable-next-line @typescript-eslint/no-deprecated\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 as React.ElementType<R[K]>, 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,4DAA4D;IAC5D,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,4DAA4D;IAC5D,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,WAAWM,UAAU;IAChE,KAAK,MAAMC,YAAYJ,UAAW;QAChC,4DAA4D;QAC5D,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,YAAYO;QAC9C,4DAA4D;QAC5DN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,4DAA4D;IAC5D,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,uDAAuD;IACrG,4DAA4D;IAC5D,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,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL;IAExE,OAAO;QAACD;QAAiCN;KAAkB;AAC7D"}
+{"version":3,"sources":["../src/compose/deprecated/getSlotsNext.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { ComponentState, SlotPropsRecord, UnknownSlotProps } from '../types';\nimport type { ObjectSlotProps, Slots } from './getSlots';\n\n/**\n * Similar to `getSlots`, main difference is that it's compatible with new custom jsx pragma\n *\n * This is an internal temporary method, this method will cease to exist eventually!\n *\n * * ❗️❗️ **DO NOT USE IT EXTERNALLY** ❗️❗️\n *\n * @internal\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 @typescript-eslint/no-deprecated\n  slots: Slots<R>;\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  slotProps: ObjectSlotProps<R>;\n} {\n  const typedState = state as ComponentState<R>;\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  const slotNames: (keyof R)[] = Object.keys(typedState.components);\n  for (const slotName of slotNames) {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    const [slot, props] = getSlotNext(typedState, slotName);\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\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 @typescript-eslint/no-deprecated\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    typeof state.components[slotName] === 'string'\n      ? // eslint-disable-next-line @typescript-eslint/no-deprecated\n        asProp || state.components?.[slotName] || 'div'\n      : // eslint-disable-next-line @typescript-eslint/no-deprecated\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 as React.ElementType<R[K]>, slotProps as R[K]];\n}\n"],"names":["getSlotsNext","state","typedState","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlotNext","undefined","as","asProp","propsWithoutAs","shouldOmitAsProp"],"mappings":"AAIA;;;;;;;;;CASC,GACD,OAAO,SAASA,aACdC,KAAc;IAOd,MAAMC,aAAaD;IACnB,4DAA4D;IAC5D,MAAME,QAAQ,CAAC;IACf,MAAMC,YAAY,CAAC;IAEnB,4DAA4D;IAC5D,MAAMC,YAAyBC,OAAOC,IAAI,CAACL,WAAWM,UAAU;IAChE,KAAK,MAAMC,YAAYJ,UAAW;QAChC,4DAA4D;QAC5D,MAAM,CAACK,MAAMC,MAAM,GAAGC,YAAYV,YAAYO;QAC9C,4DAA4D;QAC5DN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,4DAA4D;IAC5D,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,uDAAuD;IACrG,4DAA4D;IAC5D,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,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL;IAExE,OAAO;QAACD;QAAiCN;KAAkB;AAC7D"}

package/lib/compose/getIntrinsicElementProps.js

@@ -1,4 +1,3 @@
-import * as React from 'react';
 import { getNativeElementProps } from '../utils/getNativeElementProps';
 /**
  * Given an element tagname and user props, filters the props to only allowed props for the given

package/lib/compose/getIntrinsicElementProps.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/compose/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 *\n * @param tagName - The slot's default element type (e.g. 'div')\n * @param props - The component's props object\n * @param excludedPropNames - List of native props to exclude from the returned value\n */\nexport const getIntrinsicElementProps = <\n  Props extends UnknownSlotProps,\n  ExcludedPropKeys extends Extract<keyof Props, string> = never,\n>(\n  tagName: NonNullable<Props['as']>,\n  // eslint-disable-next-line @typescript-eslint/no-restricted-types -- in order to not introduce Type Restriction CHANGe which is kinda \"breaking change from Types POV\", we don't enforce our custom `RefAttributes` in this API, to be compatible with scenarios where non v9 interfaces might be used. This may/will change with React 19\n  props: Props & React.RefAttributes<InferredElementRefType<Props>>,\n  excludedPropNames?: ExcludedPropKeys[],\n): DistributiveOmit<Props, ExcludedPropKeys | Exclude<keyof Props, 'as' | keyof HTMLAttributes>> => {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\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;;;;;;;;;CASC,GACD,OAAO,MAAMC,2BAA2B,CAItCC,SACA,2UAA2U;AAC3UC,OACAC;QAKED;IAHF,4DAA4D;IAC5D,OAAOH,sBAELG,CAAAA,YAAAA,MAAME,EAAE,cAARF,uBAAAA,YAAYD,SAASC,OAAOC;AAChC,EAAE"}
+{"version":3,"sources":["../src/compose/getIntrinsicElementProps.ts"],"sourcesContent":["import type * 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 *\n * @param tagName - The slot's default element type (e.g. 'div')\n * @param props - The component's props object\n * @param excludedPropNames - List of native props to exclude from the returned value\n */\nexport const getIntrinsicElementProps = <\n  Props extends UnknownSlotProps,\n  ExcludedPropKeys extends Extract<keyof Props, string> = never,\n>(\n  tagName: NonNullable<Props['as']>,\n  // eslint-disable-next-line @typescript-eslint/no-restricted-types -- in order to not introduce Type Restriction CHANGe which is kinda \"breaking change from Types POV\", we don't enforce our custom `RefAttributes` in this API, to be compatible with scenarios where non v9 interfaces might be used. This may/will change with React 19\n  props: Props & React.RefAttributes<InferredElementRefType<Props>>,\n  excludedPropNames?: ExcludedPropKeys[],\n): DistributiveOmit<Props, ExcludedPropKeys | Exclude<keyof Props, 'as' | keyof HTMLAttributes>> => {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated\n  return getNativeElementProps<\n    DistributiveOmit<Props, Exclude<keyof Props, keyof HTMLAttributes | keyof UnknownSlotProps> | ExcludedPropKeys>\n  >(props.as ?? tagName, props, excludedPropNames);\n};\n"],"names":["getNativeElementProps","getIntrinsicElementProps","tagName","props","excludedPropNames","as"],"mappings":"AACA,SAASA,qBAAqB,QAAQ,iCAAiC;AAOvE;;;;;;;;;CASC,GACD,OAAO,MAAMC,2BAA2B,CAItCC,SACA,2UAA2U;AAC3UC,OACAC;QAKED;IAHF,4DAA4D;IAC5D,OAAOH,sBAELG,CAAAA,YAAAA,MAAME,EAAE,cAARF,uBAAAA,YAAYD,SAASC,OAAOC;AAChC,EAAE"}

package/lib/compose/isSlot.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/compose/isSlot.ts"],"sourcesContent":["import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { SlotComponentType } from './types';\n\n/**\n * Guard method to ensure a given element is a slot.\n * This is mainly used internally to ensure a slot is being used as a component.\n */\nexport function isSlot<Props extends {}>(element: unknown): element is SlotComponentType<Props> {\n  return Boolean((element as {} | undefined)?.hasOwnProperty(SLOT_ELEMENT_TYPE_SYMBOL));\n}\n"],"names":["SLOT_ELEMENT_TYPE_SYMBOL","isSlot","element","Boolean","hasOwnProperty"],"mappings":"AAAA,SAASA,wBAAwB,QAAQ,cAAc;AAGvD;;;CAGC,GACD,OAAO,SAASC,OAAyBC,OAAgB;IACvD,OAAOC,QAASD,oBAAAA,8BAAD,AAACA,QAA4BE,cAAc,CAACJ;AAC7D"}
+{"version":3,"sources":["../src/compose/isSlot.ts"],"sourcesContent":["import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport type { SlotComponentType } from './types';\n\n/**\n * Guard method to ensure a given element is a slot.\n * This is mainly used internally to ensure a slot is being used as a component.\n */\nexport function isSlot<Props extends {}>(element: unknown): element is SlotComponentType<Props> {\n  return Boolean((element as {} | undefined)?.hasOwnProperty(SLOT_ELEMENT_TYPE_SYMBOL));\n}\n"],"names":["SLOT_ELEMENT_TYPE_SYMBOL","isSlot","element","Boolean","hasOwnProperty"],"mappings":"AAAA,SAASA,wBAAwB,QAAQ,cAAc;AAGvD;;;CAGC,GACD,OAAO,SAASC,OAAyBC,OAAgB;IACvD,OAAOC,QAASD,oBAAAA,8BAAD,AAACA,QAA4BE,cAAc,CAACJ;AAC7D"}

package/lib/compose/types.js

@@ -1 +1,17 @@
-import * as React from 'react';
+/**
+ * This type should be used in place of `React.RefAttributes<T>` in all components that specify `ref` prop.
+ *
+ * If user is using React 18 types `>=18.2.61`, they will run into type issues of incompatible refs, using this type mitigates this issues across react type versions.
+ *
+ * @remarks
+ *
+ * React 18 types introduced Type Expansion Change to the `RefAttributes` interface as patch release.
+ * These changes were released in `@types/react@18.2.61` (replacing ref with `LegacyRef`, which leaks `string` into the union type, causing breaking changes between v8/v9 libraries):
+ *  - {@link https://github.com/DefinitelyTyped/DefinitelyTyped/pull/68720 | PR }
+ *  - {@link https://app.unpkg.com/@types/react@18.2.61/files/index.d.ts | shipped definitions }
+ *
+ *
+ * In React 19 types this was "reverted" back to the original `Ref<T>` type.
+ * In order to maintain compatibility with React 17,18,19, we are forced to use our own version of `RefAttributes`.
+ *
+ */ export { };