@fluentui/react-utilities 9.10.0 → 9.11.0

package/CHANGELOG.json

@@ -2,7 +2,58 @@
   "name": "@fluentui/react-utilities",
   "entries": [
     {
-      "date": "Wed, 28 Jun 2023 11:08:37 GMT",
+      "date": "Fri, 04 Aug 2023 08:48:24 GMT",
+      "tag": "@fluentui/react-utilities_v9.11.0",
+      "version": "9.11.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "bernardo.sunderhus@gmail.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "6a8afe2b7becaf1b10cbc9ae98b39d352b8c7026",
+            "comment": "feat: implement new slot methods (slot and assertSlots)"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 20 Jul 2023 18:27:36 GMT",
+      "tag": "@fluentui/react-utilities_v9.10.1",
+      "version": "9.10.1",
+      "comments": {
+        "none": [
+          {
+            "author": "olfedias@microsoft.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "5a4b16715e8e929f11d8113f710e578ca73acaa6",
+            "comment": "chore: migrate to monosize"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Mon, 03 Jul 2023 11:57:14 GMT",
+      "tag": "@fluentui/react-utilities_v9.10.1",
+      "version": "9.10.1",
+      "comments": {
+        "patch": [
+          {
+            "author": "bernardo.sunderhus@gmail.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "7d519bdcaef0a3249b6eae721fea0e5f096f6d35",
+            "comment": "bugfix: removes default prevention verification on selection"
+          },
+          {
+            "author": "bernardo.sunderhus@gmail.com",
+            "package": "@fluentui/react-utilities",
+            "commit": "cbfa9a3717782183ebc86149abcde6468f97afa8",
+            "comment": "chore: adds internal tag on jsdoc for getSlotsNext"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 28 Jun 2023 11:12:35 GMT",
       "tag": "@fluentui/react-utilities_v9.10.0",
       "version": "9.10.0",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,31 @@
 # Change Log - @fluentui/react-utilities
 
-This log was last generated on Wed, 28 Jun 2023 11:08:37 GMT and should not be manually modified.
+This log was last generated on Fri, 04 Aug 2023 08:48:24 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## [9.11.0](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.11.0)
+
+Fri, 04 Aug 2023 08:48:24 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.10.1..@fluentui/react-utilities_v9.11.0)
+
+### Minor changes
+
+- feat: implement new slot methods (slot and assertSlots) ([PR #28373](https://github.com/microsoft/fluentui/pull/28373) by bernardo.sunderhus@gmail.com)
+
+## [9.10.1](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.10.1)
+
+Mon, 03 Jul 2023 11:57:14 GMT 
+[Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.10.0..@fluentui/react-utilities_v9.10.1)
+
+### Patches
+
+- bugfix: removes default prevention verification on selection ([PR #28365](https://github.com/microsoft/fluentui/pull/28365) by bernardo.sunderhus@gmail.com)
+- chore: adds internal tag on jsdoc for getSlotsNext ([PR #28348](https://github.com/microsoft/fluentui/pull/28348) by bernardo.sunderhus@gmail.com)
+
 ## [9.10.0](https://github.com/microsoft/fluentui/tree/@fluentui/react-utilities_v9.10.0)
 
-Wed, 28 Jun 2023 11:08:37 GMT 
+Wed, 28 Jun 2023 11:12:35 GMT 
 [Compare changes](https://github.com/microsoft/fluentui/compare/@fluentui/react-utilities_v9.9.4..@fluentui/react-utilities_v9.10.0)
 
 ### Minor changes

package/dist/index.d.ts

@@ -1,6 +1,16 @@
 import { DispatchWithoutAction } from 'react';
 import * as React_2 from 'react';
 
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `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 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.
@@ -19,6 +29,27 @@ declare type AsIntrinsicElement<As extends keyof JSX.IntrinsicElements> = {
     as?: As;
 };
 
+/**
+ * @internal
+ * Assertion method to ensure state slots properties are properly declared.
+ * A properly declared slot must be declared by using the `slot` method.
+ *
+ * @example
+ * ```tsx
+ * export const renderInput_unstable = (state: InputState) => {
+ 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>;
+
 /**
  * Verifies if an application can use DOM.
  */
@@ -164,6 +195,11 @@ export declare function getSlots<R extends SlotPropsRecord>(state: ComponentStat
 
 /**
  * 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** ❗️❗️
  */
 export declare function getSlotsNext<R extends SlotPropsRecord>(state: ComponentState<R>): {
     slots: Slots<R>;
@@ -298,6 +334,12 @@ declare type IsSingleton<T extends string> = {
     [K in T]: Exclude<T, K> extends never ? true : false;
 }[T];
 
+/**
+ * Guard method to ensure a given element is a slot.
+ * This is mainly used internally to ensure a slot is being used as a component.
+ */
+export declare function isSlot<Props extends {}>(element: unknown): element is SlotComponentType<Props>;
+
 /**
  * Returns true if event is a touch event. Useful when sharing logic between touch and mouse interactions.
  */
@@ -369,6 +411,23 @@ export declare type OnSelectionChangeData = {
     selectedItems: Set<SelectionItemId>;
 };
 
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `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
+ * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.
+ * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`
+ * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object
+ * 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 UnknownSlotProps>(value: Props | SlotShorthandValue | undefined | null, options: {
+    renderByDefault?: boolean;
+} & SlotOptions<Props>): SlotComponentType<Props> | undefined;
+
 /**
  * @internal
  */
@@ -430,7 +489,14 @@ export declare function resetIdsForTests(): void;
  * @param value - the base shorthand props
  * @param options - options to resolve shorthand props
  */
-export declare const resolveShorthand: ResolveShorthandFunction;
+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 UnknownSlotProps | null | undefined>(value: Props | SlotShorthandValue): Props;
 
 export declare type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {
     <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;
@@ -505,6 +571,22 @@ export declare type Slot<Type extends keyof JSX.IntrinsicElements | React_2.Comp
     } & 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 {
+        always,
+        optional,
+        resolveShorthand_2 as resolveShorthand,
+        SlotOptions
+    }
+}
+export { slot }
+
+/**
+ * @internal
+ * Internal reference for the render function
+ */
+export declare const SLOT_ELEMENT_TYPE_SYMBOL: unique symbol;
+
 /**
  * @internal
  * Internal reference for the render function
@@ -518,6 +600,34 @@ export declare type SlotClassNames<Slots> = {
     [SlotName in keyof Slots]-?: string;
 };
 
+declare type SlotComponents<Slots extends SlotPropsRecord> = {
+    [K in keyof Slots]: SlotComponentType<ExtractSlotProps<Slots[K]>>;
+};
+
+/**
+ * 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 UnknownSlotProps> = Props & {
+    /**
+     * **NOTE**: Slot components are not callable.
+     */
+    (props: React_2.PropsWithChildren<{}>): React_2.ReactElement | null;
+    /**
+     * @internal
+     */
+    [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<Props>;
+    /**
+     * @internal
+     */
+    [SLOT_ELEMENT_TYPE_SYMBOL]: React_2.ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+};
+
+export declare type SlotOptions<Props extends UnknownSlotProps> = {
+    elementType: React_2.ComponentType<Props> | (Props extends AsIntrinsicElement<infer As> ? As : keyof JSX.IntrinsicElements);
+    defaultProps?: Partial<Props>;
+};
+
 /**
  * Matches any component's Slots type (such as ButtonSlots).
  *

package/lib/compose/assertSlots.js

@@ -0,0 +1,42 @@
+import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';
+import { isSlot } from './isSlot';
+/**
+ * @internal
+ * Assertion method to ensure state slots properties are properly declared.
+ * A properly declared slot must be declared by using the `slot` method.
+ *
+ * @example
+ * ```tsx
+ * export const renderInput_unstable = (state: InputState) => {
+    assertSlots<InputSlots>(state);
+    return (
+      <state.root>
+        {state.contentBefore && <state.contentBefore />}
+        <state.input />
+        {state.contentAfter && <state.contentAfter />}
+      </state.root>
+    );
+  };
+ * ```
+ */ export function assertSlots(state) {
+    /**
+   * This verification is not necessary in production
+   * as we're verifying static properties that will not change between environments
+   */ if (process.env.NODE_ENV !== 'production') {
+        const typedState = state;
+        for (const slotName of Object.keys(typedState.components)){
+            const slotElement = typedState[slotName];
+            if (slotElement === undefined) {
+                continue;
+            }
+            if (!isSlot(slotElement)) {
+                throw new Error(`${assertSlots.name} error: state.${slotName} is not a slot.\n` + `Be sure to create slots properly by using 'slot.always' or 'slot.optional'.`);
+            } else {
+                const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType  } = slotElement;
+                if (elementType !== typedState.components[slotName]) {
+                    throw new TypeError(`${assertSlots.name} error: state.${slotName} element type differs from state.components.${slotName}, ${elementType} !== ${typedState.components[slotName]}. \n` + `Be sure to create slots properly by using 'slot.always' or 'slot.optional' with the correct elementType`);
+                }
+            }
+        }
+    }
+}

package/lib/compose/assertSlots.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["assertSlots.ts"],"sourcesContent":["import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';\nimport { isSlot } from './isSlot';\nimport { ComponentState, ExtractSlotProps, SlotComponentType, SlotPropsRecord } from './types';\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      if (!isSlot(slotElement)) {\n        throw new Error(\n          `${assertSlots.name} error: state.${slotName} is not a slot.\\n` +\n            `Be sure to create slots properly by using 'slot.always' or 'slot.optional'.`,\n        );\n      } else {\n        const { [SLOT_ELEMENT_TYPE_SYMBOL]: elementType } = slotElement;\n        if (elementType !== typedState.components[slotName]) {\n          throw new TypeError(\n            `${assertSlots.name} error: state.${slotName} element type differs from state.components.${slotName}, ${elementType} !== ${typedState.components[slotName]}. \\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","assertSlots","state","process","env","NODE_ENV","typedState","slotName","Object","keys","components","slotElement","undefined","Error","name","elementType","TypeError"],"mappings":"AAAA,SAASA,wBAAwB,QAAQ,cAAc;AACvD,SAASC,MAAM,QAAQ,WAAW;AAOlC;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,YAA2CC,KAAc,EAA0C;IACjH;;;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,QAAS;YACX,CAAC;YACD,IAAI,CAACZ,OAAOW,cAAc;gBACxB,MAAM,IAAIE,MACR,CAAC,EAAEZ,YAAYa,IAAI,CAAC,cAAc,EAAEP,SAAS,iBAAiB,CAAC,GAC7D,CAAC,2EAA2E,CAAC,EAC/E;YACJ,OAAO;gBACL,MAAM,EAAE,CAACR,yBAAyB,EAAEgB,YAAW,EAAE,GAAGJ;gBACpD,IAAII,gBAAgBT,WAAWI,UAAU,CAACH,SAAS,EAAE;oBACnD,MAAM,IAAIS,UACR,CAAC,EAAEf,YAAYa,IAAI,CAAC,cAAc,EAAEP,SAAS,4CAA4C,EAAEA,SAAS,EAAE,EAAEQ,YAAY,KAAK,EAAET,WAAWI,UAAU,CAACH,SAAS,CAAC,IAAI,CAAC,GAC9J,CAAC,uGAAuG,CAAC,EAC3G;gBACJ,CAAC;YACH,CAAC;QACH;IACF,CAAC;AACH,CAAC"}

package/lib/compose/constants.js

@@ -2,3 +2,7 @@
  * @internal
  * Internal reference for the render function
  */ export const SLOT_RENDER_FUNCTION_SYMBOL = Symbol('fui.slotRenderFunction');
+/**
+ * @internal
+ * Internal reference for the render function
+ */ export const SLOT_ELEMENT_TYPE_SYMBOL = Symbol('fui.slotElementType');

package/lib/compose/constants.js.map

@@ -1 +1 @@
-{"version":3,"sources":["constants.ts"],"sourcesContent":["/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_RENDER_FUNCTION_SYMBOL = Symbol('fui.slotRenderFunction');\n"],"names":["SLOT_RENDER_FUNCTION_SYMBOL","Symbol"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,8BAA8BC,OAAO,0BAA0B"}
+{"version":3,"sources":["constants.ts"],"sourcesContent":["/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_RENDER_FUNCTION_SYMBOL = Symbol('fui.slotRenderFunction');\n/**\n * @internal\n * Internal reference for the render function\n */\nexport const SLOT_ELEMENT_TYPE_SYMBOL = Symbol('fui.slotElementType');\n"],"names":["SLOT_RENDER_FUNCTION_SYMBOL","Symbol","SLOT_ELEMENT_TYPE_SYMBOL"],"mappings":"AAAA;;;CAGC,GACD,OAAO,MAAMA,8BAA8BC,OAAO,0BAA0B;AAC5E;;;CAGC,GACD,OAAO,MAAMC,2BAA2BD,OAAO,uBAAuB"}

package/lib/compose/getSlots.js

@@ -1,5 +1,6 @@
 import * as React from 'react';
 import { omit } from '../utils/omit';
+import { isSlot } from './isSlot';
 import { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';
 /**
  * Given the state and an array of slot names, will break out `slots` and `slotProps`
@@ -40,7 +41,9 @@ function getSlot(state, slotName) {
             undefined
         ];
     }
-    const { children , as: asProp , [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction , ...rest } = props;
+    // 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 || 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;

package/lib/compose/getSlots.js.map

@@ -1 +1 @@
-{"version":3,"sources":["getSlots.ts"],"sourcesContent":["import * as React from 'react';\n\nimport { omit } from '../utils/omit';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\nimport type {\n  AsIntrinsicElement,\n  ComponentState,\n  ExtractSlotProps,\n  SlotPropsRecord,\n  SlotRenderFunction,\n  UnionToIntersection,\n  UnknownSlotProps,\n} from './types';\n\nexport type Slots<S extends SlotPropsRecord> = {\n  [K in keyof S]: ExtractSlotProps<S[K]> extends AsIntrinsicElement<infer As>\n    ? // for slots with an `as` prop, the slot will be any one of the possible values of `as`\n      As\n    : ExtractSlotProps<S[K]> extends React.ComponentType<infer P>\n    ? React.ElementType<NonNullable<P>>\n    : React.ElementType<ExtractSlotProps<S[K]>>;\n};\n\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 * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  const props = state[slotName];\n\n  if (props === undefined) {\n    return [null, undefined as R[K]];\n  }\n\n  const {\n    children,\n    as: asProp,\n    [SLOT_RENDER_FUNCTION_SYMBOL]: renderFunction,\n    ...rest\n  } = props as typeof props & { [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<R[K]> };\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","SLOT_RENDER_FUNCTION_SYMBOL","getSlots","state","slots","slotProps","slotNames","Object","keys","components","slotName","slot","props","getSlot","undefined","children","as","asProp","renderFunction","rest","render","Fragment","shouldOmitAsProp"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,SAASC,IAAI,QAAQ,gBAAgB;AACrC,SAASC,2BAA2B,QAAQ,cAAc;AA8B1D;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,SACdC,KAAwB,EAIxB;IACA,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;QACrCN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE,CAAC;AAED,SAASQ,QACPV,KAAwB,EACxBO,QAAW,EACsC;QAe/CP,mBACcA;IAfhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC,IAAI;YAAEA;SAAkB;IAClC,CAAC;IAED,MAAM,EACJC,SAAQ,EACRC,IAAIC,OAAM,EACV,CAAChB,4BAA4B,EAAEiB,eAAc,EAC7C,GAAGC,MACJ,GAAGP;IAEJ,MAAMD,OACJR,CAAAA,CAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,+BAAAA,KAAAA,IAAAA,iBAAkB,CAACO,SAAS,AAAD,MAAMI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFO,UAAUd,CAAAA,CAAAA,qBAAAA,MAAMM,UAAU,cAAhBN,gCAAAA,KAAAA,IAAAA,kBAAkB,CAACO,SAAS,AAAD,KAAK,QAC1CP,MAAMM,UAAU,CAACC,SAAS;IAGhC,IAAIQ,kBAAkB,OAAOH,aAAa,YAAY;QACpD,MAAMK,SAASF,kBAAmBH;QAClC,OAAO;YACLhB,MAAMsB,QAAQ;YACd;gBACEN,UAAUK,OAAOT,MAAMQ;YACzB;SACD;IACH,CAAC;IAED,MAAMG,mBAAmB,OAAOX,SAAS,YAAYM;IACrD,MAAMZ,YAAaiB,mBAAmBtB,KAAKY,OAAO;QAAC;KAAK,IAAKA,KAA0B;IACvF,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  UnionToIntersection,\n  UnknownSlotProps,\n} from './types';\nimport { isSlot } from './isSlot';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\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\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 * @param state - State including slot definitions\n * @returns An object containing the `slots` map and `slotProps` map.\n */\nexport function getSlots<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlot(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\nfunction getSlot<R extends SlotPropsRecord, K extends keyof R>(\n  state: ComponentState<R>,\n  slotName: K,\n): readonly [React.ElementType<R[K]> | null, R[K]] {\n  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,gBAAgB;AAUrC,SAASC,MAAM,QAAQ,WAAW;AAClC,SAASC,2BAA2B,QAAQ,cAAc;AAqB1D;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,SACdC,KAAwB,EAIxB;IACA,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;QACrCN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE,CAAC;AAED,SAASQ,QACPV,KAAwB,EACxBO,QAAW,EACsC;QAc/CP,mBACcA;IAdhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC,IAAI;YAAEA;SAAkB;IAClC,CAAC;IAGD,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,OAAM,EAAEC,SAAQ,EAAE,GAAGC,MAAM,GAAGN;IAE1C,MAAMO,iBAAiBnB,OAAOY,SAASA,KAAK,CAACX,4BAA4B,GAAGa,SAAS;IAErF,MAAMH,OACJR,CAAAA,CAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,+BAAAA,KAAAA,IAAAA,iBAAkB,CAACO,SAAS,AAAD,MAAMI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFM,UAAUb,CAAAA,CAAAA,qBAAAA,MAAMM,UAAU,cAAhBN,gCAAAA,KAAAA,IAAAA,kBAAkB,CAACO,SAAS,AAAD,KAAK,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,CAAC;IAED,MAAMI,mBAAmB,OAAOX,SAAS,YAAYK;IACrD,MAAMX,YAAaiB,mBAAmBvB,KAAKa,OAAO;QAAC;KAAK,IAAKA,KAA0B;IACvF,OAAO;QAACD;QAAMN;KAAU;AAC1B"}

package/lib/compose/getSlotsNext.js

@@ -1,6 +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** ❗️❗️
  */ export function getSlotsNext(state) {
     const slots = {};
     const slotProps = {};

package/lib/compose/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 */\nexport function getSlotsNext<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlotNext(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\nfunction 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;;CAEC,GACD,OAAO,SAASC,aACdC,KAAwB,EAIxB;IACA,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,YAAYV,OAAOO;QACzCN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE,CAAC;AAED,SAASQ,YACPV,KAAwB,EACxBO,QAAW,EACsC;QAY/CP,mBACcA;IAZhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC,IAAI;YAAEA;SAAkB;IAClC,CAAC;IAGD,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,OAAM,EAAE,GAAGC,gBAAgB,GAAGL;IAE1C,MAAMD,OACJR,CAAAA,CAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,+BAAAA,KAAAA,IAAAA,iBAAkB,CAACO,SAAS,AAAD,MAAMI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFM,UAAUb,CAAAA,CAAAA,qBAAAA,MAAMM,UAAU,cAAhBN,gCAAAA,KAAAA,IAAAA,kBAAkB,CAACO,SAAS,AAAD,KAAK,QAC1CP,MAAMM,UAAU,CAACC,SAAS;IAGhC,MAAMQ,mBAAmB,OAAOP,SAAS,YAAYK;IACrD,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL,KAAK;IAE7E,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 */\nexport function getSlotsNext<R extends SlotPropsRecord>(\n  state: ComponentState<R>,\n): {\n  slots: Slots<R>;\n  slotProps: ObjectSlotProps<R>;\n} {\n  const slots = {} as Slots<R>;\n  const slotProps = {} as R;\n\n  const slotNames: (keyof R)[] = Object.keys(state.components);\n  for (const slotName of slotNames) {\n    const [slot, props] = getSlotNext(state, slotName);\n    slots[slotName] = slot as Slots<R>[typeof slotName];\n    slotProps[slotName] = props;\n  }\n  return { slots, slotProps: slotProps as unknown as ObjectSlotProps<R> };\n}\n\nfunction 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;;;;;;;CAOC,GACD,OAAO,SAASC,aACdC,KAAwB,EAIxB;IACA,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,YAAYV,OAAOO;QACzCN,KAAK,CAACM,SAAS,GAAGC;QAClBN,SAAS,CAACK,SAAS,GAAGE;IACxB;IACA,OAAO;QAAER;QAAOC,WAAWA;IAA2C;AACxE,CAAC;AAED,SAASQ,YACPV,KAAwB,EACxBO,QAAW,EACsC;QAY/CP,mBACcA;IAZhB,MAAMS,QAAQT,KAAK,CAACO,SAAS;IAE7B,IAAIE,UAAUE,WAAW;QACvB,OAAO;YAAC,IAAI;YAAEA;SAAkB;IAClC,CAAC;IAGD,yFAAyF;IACzF,MAAM,EAAEC,IAAIC,OAAM,EAAE,GAAGC,gBAAgB,GAAGL;IAE1C,MAAMD,OACJR,CAAAA,CAAAA,oBAAAA,MAAMM,UAAU,cAAhBN,+BAAAA,KAAAA,IAAAA,iBAAkB,CAACO,SAAS,AAAD,MAAMI,aAAa,OAAOX,MAAMM,UAAU,CAACC,SAAS,KAAK,WAChFM,UAAUb,CAAAA,CAAAA,qBAAAA,MAAMM,UAAU,cAAhBN,gCAAAA,KAAAA,IAAAA,kBAAkB,CAACO,SAAS,AAAD,KAAK,QAC1CP,MAAMM,UAAU,CAACC,SAAS;IAGhC,MAAMQ,mBAAmB,OAAOP,SAAS,YAAYK;IACrD,MAAMX,YAA8Ba,mBAAmBD,iBAAiBL,KAAK;IAE7E,OAAO;QAACD;QAAMN;KAAkB;AAClC"}

package/lib/compose/index.js

@@ -1,6 +1,10 @@
+import * as slot from './slot';
 export * from './getSlots';
 export * from './resolveShorthand';
 export * from './types';
 export * from './isResolvedShorthand';
 export * from './constants';
 export * from './getSlotsNext';
+export * from './isSlot';
+export * from './assertSlots';
+export { slot };

package/lib/compose/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './getSlots';\nexport * from './resolveShorthand';\nexport * from './types';\nexport * from './isResolvedShorthand';\nexport * from './constants';\nexport * from './getSlotsNext';\n"],"names":[],"mappings":"AAAA,cAAc,aAAa;AAC3B,cAAc,qBAAqB;AACnC,cAAc,UAAU;AACxB,cAAc,wBAAwB;AACtC,cAAc,cAAc;AAC5B,cAAc,iBAAiB"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["import * as slot from './slot';\n\nexport * from './getSlots';\nexport * from './resolveShorthand';\nexport * from './types';\nexport * from './isResolvedShorthand';\nexport * from './constants';\nexport * from './getSlotsNext';\nexport * from './isSlot';\nexport * from './assertSlots';\n\nexport { slot };\nexport type { SlotOptions } from './slot';\n"],"names":["slot"],"mappings":"AAAA,YAAYA,UAAU,SAAS;AAE/B,cAAc,aAAa;AAC3B,cAAc,qBAAqB;AACnC,cAAc,UAAU;AACxB,cAAc,wBAAwB;AACtC,cAAc,cAAc;AAC5B,cAAc,iBAAiB;AAC/B,cAAc,WAAW;AACzB,cAAc,gBAAgB;AAE9B,SAASA,IAAI,GAAG"}

package/lib/compose/isSlot.js

@@ -0,0 +1,7 @@
+import { SLOT_ELEMENT_TYPE_SYMBOL } from './constants';
+/**
+ * Guard method to ensure a given element is a slot.
+ * This is mainly used internally to ensure a slot is being used as a component.
+ */ export function isSlot(element) {
+    return Boolean(element === null || element === void 0 ? void 0 : element.hasOwnProperty(SLOT_ELEMENT_TYPE_SYMBOL));
+}

package/lib/compose/isSlot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["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,EAAuC;IAC9F,OAAOC,QAAQ,AAACD,oBAAAA,qBAAD,KAAA,IAAA,AAACA,QAA4BE,cAAc,CAACJ;AAC7D,CAAC"}

package/lib/compose/resolveShorthand.js

@@ -1,29 +1,15 @@
-import { isValidElement } from 'react';
-import { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';
+import * as slot from './slot';
 /**
  * Resolves shorthands into slot props, to ensure normalization of the signature
  * being passed down to getSlots method
  * @param value - the base shorthand props
  * @param options - options to resolve shorthand props
  */ export const resolveShorthand = (value, options)=>{
-    const { required =false , defaultProps  } = options || {};
-    if (value === null || value === undefined && !required) {
-        return undefined;
-    }
-    let resolvedShorthand = {};
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement(value)) {
-        resolvedShorthand.children = value;
-    } else if (typeof value === 'object') {
-        resolvedShorthand = value;
-    }
-    resolvedShorthand = {
-        ...defaultProps,
-        ...resolvedShorthand
-    };
-    if (typeof resolvedShorthand.children === 'function') {
-        resolvedShorthand[SLOT_RENDER_FUNCTION_SYMBOL] = resolvedShorthand.children;
-        resolvedShorthand.children = defaultProps === null || defaultProps === void 0 ? void 0 : defaultProps.children;
-    }
-    return resolvedShorthand;
+    return slot.optional(value, {
+        ...options,
+        renderByDefault: options === null || options === void 0 ? void 0 : options.required,
+        // elementType as undefined is the way to identify between a slot and a resolveShorthand call
+        // in the case elementType is undefined assertSlots will fail, ensuring it'll only work with slot method.
+        elementType: undefined
+    });
 };

package/lib/compose/resolveShorthand.js.map

@@ -1 +1 @@
-{"version":3,"sources":["resolveShorthand.ts"],"sourcesContent":["import { isValidElement } from 'react';\nimport type { SlotRenderFunction, SlotShorthandValue, UnknownSlotProps } from './types';\nimport { SLOT_RENDER_FUNCTION_SYMBOL } from './constants';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true\n  ? { required: true; defaultProps?: Props }\n  : { required?: Required; defaultProps?: Props };\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;\n  <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | P\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction = (value, options) => {\n  const { required = false, defaultProps } = options || {};\n  if (value === null || (value === undefined && !required)) {\n    return undefined;\n  }\n\n  let resolvedShorthand: UnknownSlotProps & {\n    [SLOT_RENDER_FUNCTION_SYMBOL]?: SlotRenderFunction<UnknownSlotProps>;\n  } = {};\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  if (typeof value === 'string' || typeof value === 'number' || Array.isArray(value) || isValidElement<any>(value)) {\n    resolvedShorthand.children = value;\n  } else if (typeof value === 'object') {\n    resolvedShorthand = value;\n  }\n\n  resolvedShorthand = {\n    ...defaultProps,\n    ...resolvedShorthand,\n  };\n\n  if (typeof resolvedShorthand.children === 'function') {\n    resolvedShorthand[SLOT_RENDER_FUNCTION_SYMBOL] = resolvedShorthand.children as SlotRenderFunction<UnknownSlotProps>;\n    resolvedShorthand.children = defaultProps?.children;\n  }\n\n  return resolvedShorthand;\n};\n"],"names":["isValidElement","SLOT_RENDER_FUNCTION_SYMBOL","resolveShorthand","value","options","required","defaultProps","undefined","resolvedShorthand","Array","isArray","children"],"mappings":"AAAA,SAASA,cAAc,QAAQ,QAAQ;AAEvC,SAASC,2BAA2B,QAAQ,cAAc;AAa1D;;;;;CAKC,GACD,OAAO,MAAMC,mBAA6C,CAACC,OAAOC,UAAY;IAC5E,MAAM,EAAEC,UAAW,KAAK,CAAA,EAAEC,aAAY,EAAE,GAAGF,WAAW,CAAC;IACvD,IAAID,UAAU,IAAI,IAAKA,UAAUI,aAAa,CAACF,UAAW;QACxD,OAAOE;IACT,CAAC;IAED,IAAIC,oBAEA,CAAC;IAEL,8DAA8D;IAC9D,IAAI,OAAOL,UAAU,YAAY,OAAOA,UAAU,YAAYM,MAAMC,OAAO,CAACP,UAAUH,eAAoBG,QAAQ;QAChHK,kBAAkBG,QAAQ,GAAGR;IAC/B,OAAO,IAAI,OAAOA,UAAU,UAAU;QACpCK,oBAAoBL;IACtB,CAAC;IAEDK,oBAAoB;QAClB,GAAGF,YAAY;QACf,GAAGE,iBAAiB;IACtB;IAEA,IAAI,OAAOA,kBAAkBG,QAAQ,KAAK,YAAY;QACpDH,iBAAiB,CAACP,4BAA4B,GAAGO,kBAAkBG,QAAQ;QAC3EH,kBAAkBG,QAAQ,GAAGL,yBAAAA,0BAAAA,KAAAA,IAAAA,aAAcK,QAAQ;IACrD,CAAC;IAED,OAAOH;AACT,EAAE"}
+{"version":3,"sources":["resolveShorthand.ts"],"sourcesContent":["import * as slot from './slot';\nimport type { SlotShorthandValue, UnknownSlotProps } from './types';\n\nexport type ResolveShorthandOptions<Props, Required extends boolean = false> = Required extends true\n  ? { required: true; defaultProps?: Props }\n  : { required?: Required; defaultProps?: Props };\n\nexport type ResolveShorthandFunction<Props extends UnknownSlotProps = UnknownSlotProps> = {\n  <P extends Props>(value: P | SlotShorthandValue | undefined, options: ResolveShorthandOptions<P, true>): P;\n  <P extends Props>(value: P | SlotShorthandValue | null | undefined, options?: ResolveShorthandOptions<P, boolean>):\n    | P\n    | undefined;\n};\n\n/**\n * Resolves shorthands into slot props, to ensure normalization of the signature\n * being passed down to getSlots method\n * @param value - the base shorthand props\n * @param options - options to resolve shorthand props\n */\nexport const resolveShorthand: ResolveShorthandFunction<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,SAAS;AAc/B;;;;;CAKC,GACD,OAAO,MAAMC,mBAA+D,CAACC,OAAOC;IAClFH,OAAAA,KAAKI,QAAQ,CAAmBF,OAAO;QACrC,GAAGC,OAAO;QACVE,iBAAiBF,oBAAAA,qBAAAA,KAAAA,IAAAA,QAASG,QAAQ;QAClC,6FAA6F;QAC7F,yGAAyG;QACzGC,aAAaC;IACf;EAAG"}

package/lib/compose/slot.js

@@ -0,0 +1,59 @@
+import * as React from 'react';
+import { SLOT_ELEMENT_TYPE_SYMBOL, SLOT_RENDER_FUNCTION_SYMBOL } from './constants';
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `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.
+ */ export function always(value, options) {
+    const { defaultProps , elementType  } = options;
+    const props = resolveShorthand(value);
+    /**
+   * Casting is required here as SlotComponentType is a function, not an object.
+   * Although SlotComponentType has a function signature, it is still just an object.
+   * This is required to make a slot callable (JSX compatible), this is the exact same approach
+   * that is used on `@types/react` components
+   */ const propsWithMetadata = {
+        ...defaultProps,
+        ...props,
+        [SLOT_ELEMENT_TYPE_SYMBOL]: elementType
+    };
+    if (props && typeof props.children === 'function') {
+        propsWithMetadata[SLOT_RENDER_FUNCTION_SYMBOL] = props.children;
+        propsWithMetadata.children = defaultProps === null || defaultProps === void 0 ? void 0 : defaultProps.children;
+    }
+    return propsWithMetadata;
+}
+/**
+ * Creates a slot from a slot shorthand or properties (`props.SLOT_NAME` or `props` itself)
+ * @param value - the value of the slot, it can be a slot shorthand, a slot component or a slot properties
+ * @param options - values you can pass to alter the signature of a slot, those values are:
+ *
+ * * `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
+ * * `renderByDefault` - a boolean that indicates if a slot will be rendered even if it's base value is `undefined`.
+ * By default if `props.SLOT_NAME` is `undefined` then `state.SLOT_NAME` becomes `undefined`
+ * and nothing will be rendered, but if `renderByDefault = true` then `state.SLOT_NAME` becomes an object
+ * 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`
+ */ export function optional(value, options) {
+    if (value === null || value === undefined && !options.renderByDefault) {
+        return undefined;
+    }
+    return always(value, options);
+}
+/**
+ * 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
+ */ export function resolveShorthand(value) {
+    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
+        };
+    }
+    return value;
+}

package/lib/compose/slot.js.map

@@ -0,0 +1 @@
+{"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\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"],"mappings":"AAOA,YAAYA,WAAW,QAAQ;AAC/B,SAASC,wBAAwB,EAAEC,2BAA2B,QAAQ,cAAc;AASpF;;;;;;;CAOC,GACD,OAAO,SAASC,OACdC,KAA6C,EAC7CC,OAA2B,EACD;IAC1B,MAAM,EAAEC,aAAY,EAAEC,YAAW,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,0BAAAA,KAAAA,IAAAA,aAAcK,QAAQ;IACrD,CAAC;IAED,OAAOD;AACT,CAAC;AAED;;;;;;;;;;;;CAYC,GACD,OAAO,SAASE,SACdR,KAAoD,EACpDC,OAA2D,EACrB;IACtC,IAAID,UAAU,IAAI,IAAKA,UAAUS,aAAa,CAACR,QAAQS,eAAe,EAAG;QACvE,OAAOD;IACT,CAAC;IACD,OAAOV,OAAOC,OAAOC;AACvB,CAAC;AAED;;;;CAIC,GACD,OAAO,SAASI,iBACdL,KAAiC,EAC1B;IACP,IACE,OAAOA,UAAU,YACjB,OAAOA,UAAU,YACjBW,MAAMC,OAAO,CAACZ,UACd,8DAA8D;IAC9DJ,MAAMiB,cAAc,CAAMb,QAC1B;QACA,OAAO;YAAEO,UAAUP;QAAM;IAC3B,CAAC;IAED,OAAOA;AACT,CAAC"}