@zayne-labs/toolkit-react 0.11.1 → 0.11.3

package/dist/esm/utils/index.d.ts

@@ -1,225 +1,2 @@
-import * as react10 from "react";
-import { RefCallback } from "react";
-import { AnyFunction, AnyObject, CallbackFn, EmptyObject, Prettify, UnionDiscriminator, UnionToIntersection, UnknownObject } from "@zayne-labs/toolkit-type-helpers";
-
-//#region src/utils/composeEventHandlers.d.ts
-declare const composeTwoEventHandlers: (formerHandler: AnyFunction | undefined, latterHandler: AnyFunction | undefined) => (event: unknown) => unknown;
-declare const composeEventHandlers: (...eventHandlerArray: Array<AnyFunction | undefined>) => (event: unknown) => unknown;
-//#endregion
-//#region src/utils/composeRefs.d.ts
-type PossibleRef<TRef extends HTMLElement> = React.Ref<TRef> | undefined;
-/**
- * @description Set a given ref to a given value.
- *
- * This utility takes care of different types of refs: callback refs and RefObject(s)
- */
-declare const setRef: <TRef extends HTMLElement>(ref: PossibleRef<TRef>, node: TRef | null) => ReturnType<RefCallback<TRef>>;
-/**
- * @description A utility to combine refs. Accepts callback refs and RefObject(s)
- */
-declare const composeRefs: <TRef extends HTMLElement>(...refs: Array<PossibleRef<TRef>>) => RefCallback<TRef>;
-//#endregion
-//#region src/utils/getSlot/getSlot.d.ts
-type FunctionalComponent<TProps extends UnknownObject = never> = React.FunctionComponent<TProps>;
-/**
- * @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:
- * 1. Matches by slot symbol property
- * 2. Matches by component name
- */
-declare const matchesSlotComponent: (child: React.ReactNode, SlotComponent: FunctionalComponent) => boolean;
-/**
- * @description Checks if a react child (within the children array) matches any of the provided SlotComponents.
- */
-declare const matchesAnySlotComponent: (child: React.ReactNode, SlotComponents: FunctionalComponent[]) => boolean;
-type SlotOptions = {
-  /**
-   * @description The error message to throw when multiple slots are found for a given slot component
-   */
-  errorMessage?: string;
-  /**
-   * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component
-   */
-  throwOnMultipleSlotMatch?: boolean;
-};
-/**
- * @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.
- *
- * @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found
- */
-declare const getSingleSlot: (children: React.ReactNode, SlotComponent: FunctionalComponent, options?: SlotOptions) => react10.ReactNode;
-type MultipleSlotsOptions = {
-  /**
-   * @description The error message to throw when multiple slots are found for a given slot component
-   * If a string is provided, the same message will be used for all slot components
-   * If an array is provided, each string in the array will be used as the errorMessage for the corresponding slot component
-   */
-  errorMessage?: string | string[];
-  /**
-   * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component
-   * If a boolean is provided, the same value will be used for all slot components
-   * If an array is provided, each boolean in the array will be used as the throwOnMultipleSlotMatch value for the corresponding slot component
-   */
-  throwOnMultipleSlotMatch?: boolean | boolean[];
-};
-type GetMultipleSlotsResult<TSlotComponents extends FunctionalComponent[]> = {
-  regularChildren: React.ReactNode[];
-  slots: { [Key in keyof TSlotComponents]: ReturnType<TSlotComponents[Key]> };
-};
-/**
- * @description The same as getSingleSlot, but for multiple slot components
- */
-declare const getMultipleSlots: <const TSlotComponents extends FunctionalComponent[]>(children: React.ReactNode, SlotComponents: TSlotComponents, options?: MultipleSlotsOptions) => Prettify<GetMultipleSlotsResult<TSlotComponents>>;
-/**
- * @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)
- */
-declare const getRegularChildren: (children: React.ReactNode, SlotComponentOrComponents: FunctionalComponent | FunctionalComponent[]) => react10.ReactNode[];
-//#endregion
-//#region src/utils/getSlotMap/getSlotMap.d.ts
-type GetSlotName<TSlotComponentProps extends GetSlotComponentProps> = string extends TSlotComponentProps["name"] ? never : "default" extends TSlotComponentProps["name"] ? never : TSlotComponentProps["name"];
-type GetSpecificSlotsType<TSlotComponentProps extends GetSlotComponentProps> = { [TName in keyof TSlotComponentProps as GetSlotName<TSlotComponentProps>]: Extract<TSlotComponentProps["children"], React.ReactNode> };
-/**
- * Maps slot names to their corresponding children types
- */
-type GetSlotMapResult<TSlotComponentProps extends GetSlotComponentProps> = UnionToIntersection<GetSpecificSlotsType<TSlotComponentProps>> & {
-  default: React.ReactNode[];
-};
-/**
- * Symbol used to identify SlotComponent instances
- */
-declare const slotComponentSymbol: unique symbol;
-/**
- * @description Creates a map of named slots from React children. Returns an object mapping slot names to their children,
- * with a default slot for unmatched children.
- *
- * @example
- * ```tsx
- * import { type GetSlotComponentProps, SlotComponent } from "@zayne-labs/toolkit-react/utils"
- *
- * type SlotProps = GetSlotComponentProps<"header" | "footer">;
- *
- * function Parent({ children }: { children: React.ReactNode }) {
- *   const slots = getSlotMap<SlotProps>(children);
- *
- *   return (
- *     <div>
- *       <header>{slots.header}</header>
- *       <main>{slots.default}</main>
- *       <footer>{slots.footer}</footer>
- *     </div>
- *   );
- * }
- * ```
- *
- * Usage:
- * ```tsx
- * <Parent>
- *   <SlotComponent name="header">Header Content</SlotComponent>
- *   <div>Random stuff</div>
- *   <SlotComponent name="footer">Footer Content</SlotComponent>
- * </Parent>
- * ```
- */
-declare const getSlotMap: <TSlotComponentProps extends GetSlotComponentProps>(children: React.ReactNode) => Prettify<GetSlotMapResult<TSlotComponentProps>>;
-/**
- * @description Produce props for the SlotComponent
- *
- * @example
- * ```ts
- * // Pattern One (slot or slots have same children type, which is just React.ReactNode by default)
- * type SlotProps = GetSlotComponentProps<"header" | "content" | "footer">;
- *
- * // Pattern Two (some slots can have different children type)
- * type SlotProps =  GetSlotComponentProps<"header", React.ReactNode> | GetSlotComponentProps<"header", (renderProp: RenderProp) => React.ReactNode>;
- * ```
- */
-type GetSlotComponentProps<TName extends string = string, TChildren extends CallbackFn<never, React.ReactNode> | React.ReactNode = CallbackFn<never, React.ReactNode> | React.ReactNode> = {
-  children: TChildren;
-  /**
-   * Name of the slot where content should be rendered
-   */
-  name: TName;
-};
-/**
- * @description Creates a slot component
- */
-declare const createSlotComponent: <TSlotComponentProps extends GetSlotComponentProps>() => {
-  (props: TSlotComponentProps): React.ReactNode;
-  slotSymbol: typeof slotComponentSymbol;
-};
-type SlotWithNameAndSymbol<TSlotComponentProps extends GetSlotComponentProps = GetSlotComponentProps, TOtherProps extends UnknownObject = EmptyObject> = {
-  (props: Pick<TSlotComponentProps, "children"> & TOtherProps): React.ReactNode;
-  readonly slotName?: TSlotComponentProps["name"];
-  readonly slotSymbol?: symbol;
-};
-/**
- * @description Adds a slot symbol and name to a slot component passed in
- */
-declare const withSlotNameAndSymbol: <TSlotComponentProps extends GetSlotComponentProps, TOtherProps extends UnknownObject = EmptyObject>(name: TSlotComponentProps["name"], SlotComponent?: SlotWithNameAndSymbol<TSlotComponentProps, TOtherProps>) => SlotWithNameAndSymbol<TSlotComponentProps, TOtherProps>;
-//#endregion
-//#region src/utils/mergeProps.d.ts
-type UnionToIntersection$1<TUnion> = (TUnion extends unknown ? (param: TUnion) => void : "") extends ((param: infer TParam) => void) ? TParam : "";
-/**
- * Merges multiple sets of React props.
- *
- * - It follows the Object.assign pattern where the rightmost object's fields overwrite
- * the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
- * - Event handlers are merged such that they are called in sequence (the rightmost one being called first),
- * and allows the user to prevent the previous event handlers from being executed by calling the `preventDefault` method.
- * - It also merges the `className` and `style` props, whereby the classes are concatenated
- * and the rightmost styles overwrite the previous ones.
- *
- * @important **`ref` is not merged.**
- * @param props props to merge.
- * @returns the merged props.
- */
-declare const mergeProps: <TProps extends Record<never, never>>(...propsObjectArray: Array<TProps | undefined>) => UnionToIntersection$1<TProps>;
-//#endregion
-//#region src/utils/mergeTwoProps.d.ts
-declare const mergeTwoProps: <TProps extends Record<never, never>>(formerProps: TProps | undefined, latterProps: TProps | undefined) => TProps;
-//#endregion
-//#region src/utils/types/common.d.ts
-type ForwardedRefType<TComponent extends HTMLElement | React.ElementType> = TComponent extends React.ElementType ? React.ForwardedRef<React.Ref<TComponent>> : React.ForwardedRef<TComponent>;
-type InferProps<TComponent extends HTMLElement | React.ElementType> = TComponent extends React.ElementType ? React.ComponentPropsWithRef<TComponent> : React.HTMLAttributes<TComponent>;
-type StateSetter<TSetter = unknown> = React.Dispatch<React.SetStateAction<TSetter>>;
-type CssWithCustomProperties<TExtra extends Record<string, string> = NonNullable<unknown>> = React.CSSProperties & Record<`--${string}`, string> & TExtra;
-type DefaultRenderItemErrorMessages = {
-  children: "Hey, Sorry but the children prop is redundant since you're currently using the render prop to do the same thing";
-  renderItem: "Hey, Sorry but the renderItem prop is redundant since you're currently using the children prop to do the same thing";
-};
-/**
- * @description Represents a set of props that can be used to render a component conditionally based on a discriminated union type.
- * This type allows for the use of either a render prop or children prop, but not both at the same time.
- * If both are provided, a TypeScript error will be thrown.
- * @template TErrorMessages An object of custom messages to display on the disallowed property.
- */
-type DiscriminatedRenderItemProps<TRenderItemPropType, TErrorMessages extends Record<keyof DefaultRenderItemErrorMessages, string> = DefaultRenderItemErrorMessages> = UnionDiscriminator<[{
-  children: TRenderItemPropType;
-}, {
-  renderItem: TRenderItemPropType;
-}], TErrorMessages>;
-type DefaultRenderErrorMessages = {
-  children: "Hey, Sorry but the children prop is redundant since you're currently using the render prop to do the same thing";
-  render: "Hey, Sorry but the render prop is redundant since you're currently using the children prop to do the same thing";
-};
-/**
- * @description Represents a set of props that can be used to render a component conditionally based on a discriminated union type.
- * This type allows for the use of either a render prop or children prop, but not both at the same time.
- * If both are provided, a TypeScript error will be thrown.
- * @template TErrorMessages An object of custom messages to display on the disallowed property.
- */
-type DiscriminatedRenderProps<TRenderPropType, TErrorMessages extends Record<keyof DefaultRenderErrorMessages, string> = DefaultRenderErrorMessages> = UnionDiscriminator<[{
-  children: TRenderPropType;
-}, {
-  render: TRenderPropType;
-}], TErrorMessages>;
-//#endregion
-//#region src/utils/types/polymorphism.d.ts
-type AsProp<TElement extends React.ElementType> = {
-  as?: TElement;
-};
-type InferRemainingProps<TElement extends React.ElementType, TProps> = Omit<InferProps<TElement>, keyof TProps>;
-type MergedGivenPropsWithAs<TElement extends React.ElementType, TProps> = Prettify<Omit<AsProp<TElement>, keyof TProps> & TProps>;
-type PolymorphicProps<TElement extends React.ElementType, TProps extends AnyObject = NonNullable<unknown>> = MergedGivenPropsWithAs<TElement, TProps> & InferRemainingProps<TElement, TProps>;
-//#endregion
-export { AsProp, CssWithCustomProperties, DefaultRenderErrorMessages, DefaultRenderItemErrorMessages, DiscriminatedRenderItemProps, DiscriminatedRenderProps, ForwardedRefType, FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, InferProps, PolymorphicProps, PossibleRef, StateSetter, composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol };
-//# sourceMappingURL=index.d.ts.map
+import { AsProp, CssWithCustomProperties, DefaultRenderErrorMessages, DefaultRenderItemErrorMessages, DiscriminatedRenderItemProps, DiscriminatedRenderProps, ForwardedRefType, FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, InferProps, PolymorphicProps, PossibleRef, StateSetter, composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol } from "../index-CByHxS0M.js";
+export { AsProp, CssWithCustomProperties, DefaultRenderErrorMessages, DefaultRenderItemErrorMessages, DiscriminatedRenderItemProps, DiscriminatedRenderProps, ForwardedRefType, FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, InferProps, PolymorphicProps, PossibleRef, StateSetter, composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol };

package/dist/esm/utils/index.js

@@ -1,279 +1,3 @@
-import { Fragment, isValidElement } from "react";
-import { toArray } from "@zayne-labs/toolkit-core";
-import { AssertionError, isArray, isFunction, isObject } from "@zayne-labs/toolkit-type-helpers";
+import { composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol } from "../utils-Bvs8tFDM.js";
 
-//#region src/utils/composeEventHandlers.ts
-const isSyntheticEvent = (event) => {
-	return isObject(event) && Object.hasOwn(event, "nativeEvent");
-};
-const composeTwoEventHandlers = (formerHandler, latterHandler) => {
-	const mergedEventHandler = (event) => {
-		if (isSyntheticEvent(event)) {
-			const result$1 = latterHandler?.(event);
-			if (!event.defaultPrevented) formerHandler?.(event);
-			return result$1;
-		}
-		const result = latterHandler?.(event);
-		formerHandler?.(event);
-		return result;
-	};
-	return mergedEventHandler;
-};
-const composeEventHandlers = (...eventHandlerArray) => {
-	const mergedEventHandler = (event) => {
-		if (eventHandlerArray.length === 0) return;
-		if (eventHandlerArray.length === 1) return eventHandlerArray[0]?.(event);
-		let accumulatedHandlers;
-		for (const eventHandler of eventHandlerArray) {
-			if (!eventHandler) continue;
-			accumulatedHandlers = composeTwoEventHandlers(accumulatedHandlers, eventHandler);
-		}
-		return accumulatedHandlers?.(event);
-	};
-	return mergedEventHandler;
-};
-
-//#endregion
-//#region src/utils/composeRefs.ts
-/**
-* @description Set a given ref to a given value.
-*
-* This utility takes care of different types of refs: callback refs and RefObject(s)
-*/
-const setRef = (ref, node) => {
-	if (!ref) return;
-	if (isFunction(ref)) return ref(node);
-	ref.current = node;
-};
-/**
-* @description A utility to combine refs. Accepts callback refs and RefObject(s)
-*/
-const composeRefs = (...refs) => {
-	const mergedRefCallBack = (node) => {
-		const cleanupFnArray = refs.map((ref) => setRef(ref, node));
-		const cleanupFn = () => cleanupFnArray.forEach((cleanup) => cleanup?.());
-		return cleanupFn;
-	};
-	return mergedRefCallBack;
-};
-
-//#endregion
-//#region src/utils/getSlot/getSlot.ts
-const isWithSlotSymbol = (component) => {
-	return "slotSymbol" in component && Boolean(component.slotSymbol);
-};
-const isWithSlotReference = (component) => {
-	return "slotReference" in component && Boolean(component.slotReference);
-};
-/**
-* @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:
-* 1. Matches by slot symbol property
-* 2. Matches by component name
-*/
-const matchesSlotComponent = (child, SlotComponent) => {
-	if (!isValidElement(child) || !isFunction(child.type)) return false;
-	const resolvedChildType = isWithSlotReference(child.type) ? child.type.slotReference : child.type;
-	if (isWithSlotSymbol(resolvedChildType) && isWithSlotSymbol(SlotComponent) && resolvedChildType.slotSymbol === SlotComponent.slotSymbol) return true;
-	if (child.type.name === SlotComponent.name) return true;
-	return false;
-};
-/**
-* @description Checks if a react child (within the children array) matches any of the provided SlotComponents.
-*/
-const matchesAnySlotComponent = (child, SlotComponents) => {
-	return SlotComponents.some((SlotComponent) => matchesSlotComponent(child, SlotComponent));
-};
-/**
-* @description Counts how many times a given slot component appears in an array of children
-* @internal
-*/
-const calculateSlotOccurrences = (childrenArray, SlotComponent) => {
-	let count = 0;
-	for (const child of childrenArray) {
-		if (!matchesSlotComponent(child, SlotComponent)) continue;
-		count += 1;
-	}
-	return count;
-};
-/**
-* @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.
-*
-* @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found
-*/
-const getSingleSlot = (children, SlotComponent, options = {}) => {
-	const { errorMessage = "Only one instance of the SlotComponent is allowed", throwOnMultipleSlotMatch = false } = options;
-	const actualChildren = isValidElement(children) && children.type === Fragment ? children.props.children : children;
-	const childrenArray = toArray(actualChildren);
-	if (throwOnMultipleSlotMatch && calculateSlotOccurrences(childrenArray, SlotComponent) > 1) throw new AssertionError(errorMessage);
-	return childrenArray.find((child) => matchesSlotComponent(child, SlotComponent));
-};
-/**
-* @description The same as getSingleSlot, but for multiple slot components
-*/
-const getMultipleSlots = (children, SlotComponents, options) => {
-	const { errorMessage, throwOnMultipleSlotMatch } = options ?? {};
-	const slots = SlotComponents.map((SlotComponent, index) => getSingleSlot(children, SlotComponent, {
-		errorMessage: isArray(errorMessage) ? errorMessage[index] : errorMessage,
-		throwOnMultipleSlotMatch: isArray(throwOnMultipleSlotMatch) ? throwOnMultipleSlotMatch[index] : throwOnMultipleSlotMatch
-	}));
-	return {
-		regularChildren: getRegularChildren(children, SlotComponents),
-		slots
-	};
-};
-/**
-* @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)
-*/
-const getRegularChildren = (children, SlotComponentOrComponents) => {
-	const actualChildren = isValidElement(children) && children.type === Fragment ? children.props.children : children;
-	return toArray(actualChildren).filter((child) => !matchesAnySlotComponent(child, toArray(SlotComponentOrComponents)));
-};
-
-//#endregion
-//#region src/utils/getSlotMap/getSlotMap.ts
-/**
-* Symbol used to identify SlotComponent instances
-*/
-const slotComponentSymbol = Symbol("slot-component");
-/**
-* @description Creates a map of named slots from React children. Returns an object mapping slot names to their children,
-* with a default slot for unmatched children.
-*
-* @example
-* ```tsx
-* import { type GetSlotComponentProps, SlotComponent } from "@zayne-labs/toolkit-react/utils"
-*
-* type SlotProps = GetSlotComponentProps<"header" | "footer">;
-*
-* function Parent({ children }: { children: React.ReactNode }) {
-*   const slots = getSlotMap<SlotProps>(children);
-*
-*   return (
-*     <div>
-*       <header>{slots.header}</header>
-*       <main>{slots.default}</main>
-*       <footer>{slots.footer}</footer>
-*     </div>
-*   );
-* }
-* ```
-*
-* Usage:
-* ```tsx
-* <Parent>
-*   <SlotComponent name="header">Header Content</SlotComponent>
-*   <div>Random stuff</div>
-*   <SlotComponent name="footer">Footer Content</SlotComponent>
-* </Parent>
-* ```
-*/
-const getSlotMap = (children) => {
-	const slots = { default: [] };
-	const actualChildren = isValidElement(children) && children.type === Fragment ? children.props.children : children;
-	const childrenArray = toArray(actualChildren);
-	for (const child of childrenArray) {
-		if (!isValidElement(child) || !isFunction(child.type)) {
-			slots.default.push(child);
-			continue;
-		}
-		const childType = child.type;
-		if (!(childType.slotSymbol === slotComponentSymbol && Boolean(childType.slotName ?? child.props.name))) {
-			slots.default.push(child);
-			continue;
-		}
-		const slotName = childType.slotName ?? child.props.name;
-		if (slotName === "default") {
-			slots.default.push(child);
-			continue;
-		}
-		slots[slotName] = child;
-	}
-	return slots;
-};
-/**
-* @description Creates a slot component
-*/
-const createSlotComponent = () => {
-	const SlotComponent = (props) => props.children;
-	SlotComponent.slotSymbol = slotComponentSymbol;
-	return SlotComponent;
-};
-function DefaultSlotComponent(props) {
-	return props.children;
-}
-/**
-* @description Adds a slot symbol and name to a slot component passed in
-*/
-const withSlotNameAndSymbol = (name, SlotComponent = DefaultSlotComponent) => {
-	SlotComponent.slotSymbol = slotComponentSymbol;
-	SlotComponent.slotName = name;
-	return SlotComponent;
-};
-
-//#endregion
-//#region src/utils/mergeTwoProps.ts
-const isEventHandler = (key, value) => {
-	const thirdCharCode = key.codePointAt(2);
-	if (!isFunction(value) || thirdCharCode === void 0) return false;
-	return key.startsWith("on") && thirdCharCode >= 65 && thirdCharCode <= 90;
-};
-const mergeTwoClassNames = (formerClassName, latterClassName) => {
-	if (!latterClassName || !formerClassName) return latterClassName || formerClassName;
-	return formerClassName + " " + latterClassName;
-};
-const mergeTwoProps = (formerProps, latterProps) => {
-	if (!latterProps || !formerProps) return latterProps ?? formerProps ?? {};
-	const propsAccumulator = { ...formerProps };
-	for (const latterPropName of Object.keys(latterProps)) {
-		const formerPropValue = formerProps[latterPropName];
-		const latterPropValue = latterProps[latterPropName];
-		if (latterPropName === "className" || latterPropName === "class") {
-			propsAccumulator[latterPropName] = mergeTwoClassNames(formerPropValue, latterPropValue);
-			continue;
-		}
-		if (latterPropName === "style") {
-			propsAccumulator[latterPropName] = {
-				...formerPropValue,
-				...latterPropValue
-			};
-			continue;
-		}
-		if (isEventHandler(latterPropName, latterPropValue)) {
-			propsAccumulator[latterPropName] = composeTwoEventHandlers(formerPropValue, latterPropValue);
-			continue;
-		}
-		propsAccumulator[latterPropName] = latterPropValue;
-	}
-	return propsAccumulator;
-};
-
-//#endregion
-//#region src/utils/mergeProps.ts
-/**
-* Merges multiple sets of React props.
-*
-* - It follows the Object.assign pattern where the rightmost object's fields overwrite
-* the conflicting ones from others. This doesn't apply to event handlers, `className` and `style` props.
-* - Event handlers are merged such that they are called in sequence (the rightmost one being called first),
-* and allows the user to prevent the previous event handlers from being executed by calling the `preventDefault` method.
-* - It also merges the `className` and `style` props, whereby the classes are concatenated
-* and the rightmost styles overwrite the previous ones.
-*
-* @important **`ref` is not merged.**
-* @param props props to merge.
-* @returns the merged props.
-*/
-const mergeProps = (...propsObjectArray) => {
-	if (propsObjectArray.length === 0) return {};
-	if (propsObjectArray.length === 1) return propsObjectArray[0];
-	let accumulatedProps = {};
-	for (const propsObject of propsObjectArray) {
-		if (!propsObject) continue;
-		accumulatedProps = mergeTwoProps(accumulatedProps, propsObject);
-	}
-	return accumulatedProps;
-};
-
-//#endregion
-export { composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol };
-//# sourceMappingURL=index.js.map
+export { composeEventHandlers, composeRefs, composeTwoEventHandlers, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, mergeProps, mergeTwoProps, setRef, slotComponentSymbol, withSlotNameAndSymbol };