@zayne-labs/ui-react 0.9.16 → 0.9.18

package/dist/esm/index-BSJ30pGj.d.ts

@@ -0,0 +1,68 @@
+import * as React$1 from "react";
+import { Component } from "react";
+
+//#region src/components/common/error-boundary/types.d.ts
+type FallbackProps = {
+  error: unknown;
+  resetErrorBoundary: (...args: unknown[]) => void;
+};
+type ErrorBoundaryProps = {
+  children: React.ReactNode;
+  fallback?: React.ReactNode | ((props: FallbackProps) => React.ReactNode);
+  onError?: (context: {
+    error: Error;
+    info: React.ErrorInfo & {
+      ownerStack?: string;
+    };
+  }) => void;
+  onReset?: (context: {
+    args: unknown[];
+    reason: "imperative-api";
+  } | {
+    next: unknown[] | undefined;
+    prev: unknown[] | undefined;
+    reason: "keys";
+  }) => void;
+  resetKeys?: unknown[];
+}; //#endregion
+//#region src/components/common/error-boundary/error-boundary.d.ts
+type ErrorBoundaryState = {
+  error: Error;
+  hasError: true;
+} | {
+  error: null;
+  hasError: false;
+};
+/**
+ * Copied from react-error-boundary package
+ * @see https://github.com/bvaughn/react-error-boundary
+ */
+declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  #private;
+  constructor(props: ErrorBoundaryProps);
+  static getDerivedStateFromError(error: Error): {
+    error: Error;
+    hasError: boolean;
+  };
+  componentDidCatch(error: Error, info: React$1.ErrorInfo): void;
+  componentDidUpdate(prevProps: ErrorBoundaryProps, prevState: ErrorBoundaryState): void;
+  render(): React$1.JSX.Element;
+}
+
+//#endregion
+//#region src/components/common/error-boundary/error-boundary-context.d.ts
+type ErrorBoundaryContextType = {
+  error: unknown;
+  hasError: boolean;
+  resetErrorBoundary: (...args: unknown[]) => void;
+};
+//#endregion
+//#region src/components/common/error-boundary/useErrorBoundary.d.ts
+declare const useErrorBoundary: <TError extends Error>() => {
+  resetBoundary: () => void;
+  showBoundary: (error: TError) => void;
+};
+
+//#endregion
+export { ErrorBoundary as ErrorBoundary$1, ErrorBoundaryContextType, ErrorBoundaryProps, FallbackProps, useErrorBoundary as useErrorBoundary$1, useErrorBoundaryContext as useErrorBoundaryContext$1 };
+//# sourceMappingURL=index-BSJ30pGj.d.ts.map

package/dist/esm/{for-BH5FhFuV.d.ts → index-BhpBx8dH.d.ts}

@@ -1,14 +1,22 @@
-import * as React from 'react';
-import { DiscriminatedRenderProps, PolymorphicProps } from '@zayne-labs/toolkit-react/utils';
-import { Prettify, ExtractUnion } from '@zayne-labs/toolkit-type-helpers';
+import * as React from "react";
+import { ExtractUnion, Prettify } from "@zayne-labs/toolkit-type-helpers";
+import { DiscriminatedRenderProps, PolymorphicProps } from "@zayne-labs/toolkit-react/utils";
 
+//#region src/components/common/for/for.d.ts
 type RenderPropFn<TArray> = (item: TArray extends readonly unknown[] ? ExtractUnion<TArray> : TArray extends number ? number : unknown, index: number, array: TArray extends readonly unknown[] ? TArray : TArray extends number ? number[] : unknown[]) => React.ReactNode;
 type ForRenderProps<TArrayItem> = DiscriminatedRenderProps<RenderPropFn<TArrayItem>>;
 type ForProps<TArray> = Prettify<{
-    each: TArray;
-    fallback?: React.ReactNode;
+  each: TArray;
+  fallback?: React.ReactNode;
 } & ForRenderProps<TArray>>;
 declare function For<const TArray>(props: ForProps<TArray>): string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
 declare function ForWithWrapper<TArrayItem, TElement extends React.ElementType = "ul">(props: PolymorphicProps<TElement, ForProps<TArrayItem>>): React.JSX.Element;
 
-export { For as F, ForWithWrapper as a, type ForRenderProps as b };
+//#endregion
+//#region src/components/common/for/getElementList.d.ts
+type GetElementListResult<TVariant extends "base" | "withWrapper"> = TVariant extends "base" ? [typeof For] : [typeof ForWithWrapper];
+declare const getElementList: <TVariant extends "base" | "withWrapper" = "withWrapper">(variant?: TVariant) => GetElementListResult<TVariant>;
+
+//#endregion
+export { For as For$1, ForRenderProps, ForWithWrapper as ForWithWrapper$1, getElementList as getElementList$1 };
+//# sourceMappingURL=index-BhpBx8dH.d.ts.map

package/dist/esm/index-BuSQsDCX.d.ts

@@ -0,0 +1,22 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import * as React from "react";
+import { PolymorphicProps } from "@zayne-labs/toolkit-react/utils";
+
+//#region src/components/ui/card/card.d.ts
+declare function CardRoot<TElement extends React.ElementType = "article">(props: PolymorphicProps<TElement>): React.JSX.Element;
+declare function CardHeader<TElement extends React.ElementType = "header">(props: PolymorphicProps<TElement>): React.JSX.Element;
+declare function CardTitle<TElement extends React.ElementType = "h3">(props: PolymorphicProps<TElement>): React.JSX.Element;
+declare function CardDescription<TElement extends React.ElementType = "p">(props: PolymorphicProps<TElement>): React.JSX.Element;
+declare function CardContent<TElement extends React.ElementType = "div">(props: PolymorphicProps<TElement>): React.JSX.Element;
+declare function CardFooter<TElement extends React.ElementType = "footer">(props: PolymorphicProps<TElement, {
+  asChild?: boolean;
+}>): React.JSX.Element;
+
+//#endregion
+//#region src/components/ui/card/card-parts.d.ts
+declare namespace card_parts_d_exports {
+  export { CardContent as Content, CardDescription as Description, CardFooter as Footer, CardHeader as Header, CardRoot as Root, CardTitle as Title };
+}
+//#endregion
+export { CardContent as CardContent$1, CardDescription as CardDescription$1, CardFooter as CardFooter$1, CardHeader as CardHeader$1, CardRoot as CardRoot$1, CardTitle as CardTitle$1, card_parts_d_exports };
+//# sourceMappingURL=index-BuSQsDCX.d.ts.map

package/dist/esm/index-C0XZoIZD.d.ts

@@ -0,0 +1,35 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import * as React from "react";
+
+//#region src/components/common/show/show.d.ts
+type ShowProps<TWhen> = {
+  children: React.ReactNode | ((value: TWhen) => React.ReactNode);
+  fallback?: React.ReactNode;
+  when: false | TWhen | null | undefined;
+};
+declare function ShowRoot<TWhen>(props: ShowProps<TWhen>): string | number | bigint | boolean | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | React.ReactPortal | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | Iterable<React.ReactNode> | null | undefined> | null;
+declare function ShowContent({
+  children
+}: {
+  children: React.ReactNode;
+}): React.ReactNode;
+declare namespace ShowContent {
+  var slotSymbol: symbol;
+}
+declare function ShowFallback({
+  children
+}: {
+  children: React.ReactNode;
+}): React.ReactNode;
+declare namespace ShowFallback {
+  var slotSymbol: symbol;
+}
+
+//#endregion
+//#region src/components/common/show/show-parts.d.ts
+declare namespace show_parts_d_exports {
+  export { ShowContent as Content, ShowFallback as Fallback, ShowFallback as Otherwise, ShowRoot as Root };
+}
+//#endregion
+export { ShowContent as ShowContent$1, ShowFallback as ShowFallback$1, ShowRoot as ShowRoot$1, show_parts_d_exports };
+//# sourceMappingURL=index-C0XZoIZD.d.ts.map

package/dist/esm/index-CTZr4PTO.d.ts

@@ -0,0 +1,24 @@
+import { InferProps } from "@zayne-labs/toolkit-react/utils";
+
+//#region src/components/ui/drag-scroll/use-drag-scroll.d.ts
+type ItemProps<TItemElement extends HTMLElement> = Omit<InferProps<TItemElement>, "children">;
+type RootProps<TElement extends HTMLElement> = Omit<InferProps<TElement>, "children">;
+type DragScrollProps<TElement extends HTMLElement, TItemElement extends HTMLElement> = {
+  classNames?: {
+    base?: string;
+    item?: string;
+  };
+  extraItemProps?: ItemProps<TItemElement>;
+  extraRootProps?: InferProps<TElement>;
+  orientation?: "both" | "horizontal" | "vertical";
+  usage?: "allScreens" | "desktopOnly" | "mobileAndTabletOnly";
+};
+type DragScrollResult<TElement extends HTMLElement, TItemElement extends HTMLElement> = {
+  getItemProps: (itemProps?: ItemProps<TItemElement>) => ItemProps<TItemElement>;
+  getRootProps: (rootProps?: RootProps<TElement>) => RootProps<TElement>;
+};
+declare const useDragScroll: <TElement extends HTMLElement, TItemElement extends HTMLElement = HTMLElement>(props?: DragScrollProps<TElement, TItemElement>) => DragScrollResult<TElement, TItemElement>;
+
+//#endregion
+export { useDragScroll as useDragScroll$1 };
+//# sourceMappingURL=index-CTZr4PTO.d.ts.map

package/dist/esm/index-CqlM1M0j.d.ts

@@ -0,0 +1,14 @@
+import { ErrorBoundaryProps } from "./index-BSJ30pGj.js";
+import * as react1 from "react";
+
+//#region src/components/common/suspense-with-boundary/suspense-with-boundary.d.ts
+type SuspenseWithBoundaryProps = {
+  children: React.ReactNode;
+  errorFallback?: ErrorBoundaryProps["fallback"];
+  fallback?: React.ReactNode;
+};
+declare function SuspenseWithBoundary(props: SuspenseWithBoundaryProps): react1.JSX.Element;
+
+//#endregion
+export { SuspenseWithBoundary as SuspenseWithBoundary$1, SuspenseWithBoundaryProps };
+//# sourceMappingURL=index-CqlM1M0j.d.ts.map

package/dist/esm/index-D-j2Cn1J.d.ts

@@ -0,0 +1,61 @@
+import * as react8 from "react";
+import { Prettify, UnknownObject } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/lib/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) => react8.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[]) => react8.ReactNode[];
+
+//#endregion
+export { FunctionalComponent, getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent };
+//# sourceMappingURL=index-D-j2Cn1J.d.ts.map

package/dist/esm/index-DQ1yFGd2.d.ts

@@ -0,0 +1,229 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import * as React$1 from "react";
+import { UnionDiscriminator } from "@zayne-labs/toolkit-type-helpers";
+import { DiscriminatedRenderProps, InferProps, PolymorphicProps } from "@zayne-labs/toolkit-react/utils";
+import { Control, ControllerFieldState, ControllerProps, ControllerRenderProps, FieldPath, FieldPathValue, FieldPathValues, RegisterOptions, UseFormReturn, UseFormStateReturn, useFormContext as useFormRootContext } from "react-hook-form";
+
+//#region src/components/ui/form/form-context.d.ts
+
+type RenderIconProps = {
+  isPasswordVisible: boolean;
+};
+type EyeIconObject = UnionDiscriminator<[{
+  closed: React.ReactNode;
+  open: React.ReactNode;
+}, {
+  renderIcon: (props: RenderIconProps) => React.ReactNode;
+}]>;
+type FormRootContext = {
+  withEyeIcon: boolean | EyeIconObject | undefined;
+};
+type FieldContextValue = {
+  formDescriptionId: `${string}-(${string})-form-item-description`;
+  formItemId: `${string}-(${string})-form-item`;
+  formMessageId: `${string}-(${string})-form-item-message`;
+  name: string;
+};
+type FormFieldContextProps = DiscriminatedRenderProps<(contextValue: FieldContextValue) => React.ReactNode>;
+type FieldState = {
+  errors?: UseFormStateReturn<FieldValues>["errors"];
+  isDisabled?: boolean;
+  isInvalid?: boolean;
+}; //#endregion
+//#region src/components/ui/form/form.d.ts
+type FieldValues = Record<string, unknown>;
+type FormRootProps<TFieldValues extends FieldValues> = Partial<FormRootContext> & React$1.ComponentPropsWithoutRef<"form"> & {
+  children: React$1.ReactNode;
+  methods: UseFormReturn<TFieldValues>;
+};
+declare function FormRoot<TValues extends FieldValues>(props: FormRootProps<TValues>): React$1.JSX.Element;
+type FormFieldProps<TControl, TFieldValues extends FieldValues> = (TControl extends Control<infer TValues> ? {
+  control?: never;
+  name: FieldPath<TValues>;
+} : {
+  control?: Control<TFieldValues>;
+  name: FieldPath<TFieldValues>;
+}) & ((InferProps<"div"> & {
+  withWrapper?: true;
+}) | {
+  children: React$1.ReactNode;
+  className?: never;
+  withWrapper: false;
+});
+declare function FormField<TControl, TFieldValues extends FieldValues = FieldValues>(props: FormFieldProps<TControl, TFieldValues>): React$1.JSX.Element;
+type FormFieldControllerRenderFn = (props: {
+  field: Omit<ControllerRenderProps, "value"> & {
+    value: never;
+  };
+  fieldState: ControllerFieldState;
+  formState: UseFormStateReturn<never>;
+}) => React$1.ReactElement;
+type FormFieldControllerProps = Omit<ControllerProps<FieldValues, FieldPath<FieldValues>>, "control" | "name" | "render"> & {
+  render: FormFieldControllerRenderFn;
+};
+declare function FormFieldController(props: FormFieldControllerProps): React$1.JSX.Element;
+declare function FormFieldControlledField<TFieldValues extends FieldValues>(props: ControllerProps<TFieldValues>): React$1.JSX.Element;
+declare function FormFieldContext(props: FormFieldContextProps): React$1.ReactNode;
+declare function FormLabel(props: InferProps<"label">): React$1.JSX.Element;
+declare function FormInputGroup(props: InferProps<"div">): React$1.JSX.Element;
+type FormSideItemProps = {
+  children?: React$1.ReactNode;
+  className?: string;
+};
+declare function FormInputLeftItem<TElement extends React$1.ElementType = "span">(props: PolymorphicProps<TElement, FormSideItemProps>): React$1.JSX.Element;
+declare namespace FormInputLeftItem {
+  var slotSymbol: symbol;
+}
+declare function FormInputRightItem<TElement extends React$1.ElementType = "span">(props: PolymorphicProps<TElement, FormSideItemProps>): React$1.JSX.Element;
+declare namespace FormInputRightItem {
+  var slotSymbol: symbol;
+}
+type FormInputPrimitiveProps<TFieldValues extends FieldValues = FieldValues> = Omit<React$1.ComponentPropsWithRef<"input">, "children"> & {
+  classNames?: {
+    error?: string;
+    eyeIcon?: string;
+    input?: string;
+    inputGroup?: string;
+  };
+  control?: Control<TFieldValues>;
+  fieldState?: FieldState;
+  name?: FieldPath<TFieldValues>;
+  withEyeIcon?: FormRootContext["withEyeIcon"];
+};
+type FormTextAreaPrimitiveProps<TFieldValues extends FieldValues = FieldValues> = React$1.ComponentPropsWithRef<"textarea"> & {
+  classNames?: {
+    base?: string;
+    error?: string;
+  };
+  control?: Control<TFieldValues>;
+  fieldState?: FieldState;
+  name?: FieldPath<TFieldValues>;
+};
+type FormSelectPrimitiveProps<TFieldValues extends FieldValues = FieldValues> = React$1.ComponentPropsWithRef<"select"> & {
+  classNames?: {
+    base?: string;
+    error?: string;
+  };
+  control?: Control<TFieldValues>;
+  fieldState?: FieldState;
+  name?: FieldPath<TFieldValues>;
+};
+declare function FormInputPrimitive<TFieldValues extends FieldValues>(props: FormInputPrimitiveProps<TFieldValues> & {
+  rules?: RegisterOptions;
+}): React$1.JSX.Element;
+declare function FormTextAreaPrimitive<TFieldValues extends FieldValues>(props: FormTextAreaPrimitiveProps<TFieldValues> & {
+  rules?: RegisterOptions;
+}): React$1.JSX.Element;
+declare function FormSelectPrimitive<TFieldValues extends FieldValues>(props: FormSelectPrimitiveProps<TFieldValues> & {
+  rules?: RegisterOptions;
+}): React$1.JSX.Element;
+type PrimitivePropsToOmit = "control" | "formState" | "name";
+type FormInputProps = Omit<FormInputPrimitiveProps, PrimitivePropsToOmit> & {
+  rules?: RegisterOptions;
+};
+type FormTextAreaProps = Omit<FormTextAreaPrimitiveProps, PrimitivePropsToOmit> & {
+  rules?: RegisterOptions;
+};
+type FormSelectProps = Omit<FormSelectPrimitiveProps, PrimitivePropsToOmit> & {
+  rules?: RegisterOptions;
+};
+type CombinedFormInputProps = (FormSelectProps & {
+  type: "select";
+}) | (FormTextAreaProps & {
+  type: "textarea";
+}) | FormInputProps;
+declare function FormInput(props: CombinedFormInputProps & {
+  rules?: RegisterOptions;
+}): React$1.JSX.Element;
+declare function FormTextArea(props: FormTextAreaProps): React$1.JSX.Element;
+declare function FormSelect(props: FormSelectProps): React$1.JSX.Element;
+declare function FormDescription(props: InferProps<"p">): React$1.JSX.Element;
+type ErrorMessageRenderProps = {
+  className: string;
+  "data-index": number;
+  "data-part": "error-message";
+  "data-scope": "form";
+  "data-slot": "form-error-message";
+  id: string | undefined;
+  ref: React$1.RefCallback<HTMLElement>;
+};
+type ErrorMessageRenderState = {
+  errorMessage: string;
+  errorMessageArray: string[];
+  index: number;
+};
+type ErrorMessageRenderFn = (context: {
+  props: ErrorMessageRenderProps;
+  state: ErrorMessageRenderState;
+}) => React$1.ReactNode;
+type FormErrorMessagePrimitiveProps<TFieldValues extends FieldValues> = DiscriminatedRenderProps<ErrorMessageRenderFn> & {
+  className?: string;
+  classNames?: {
+    container?: string;
+    errorMessage?: string;
+    errorMessageAnimation?: string;
+  };
+  control?: Control<TFieldValues>;
+  disableErrorAnimation?: boolean;
+  disableScrollToErrorField?: boolean;
+} & ({
+  fieldName: FieldPath<TFieldValues>;
+  type?: "regular";
+} | {
+  fieldName: string;
+  type: "root";
+});
+type FormErrorMessagePrimitiveType = {
+  <TFieldValues extends FieldValues>(props: Extract<FormErrorMessagePrimitiveProps<TFieldValues>, {
+    type?: "regular";
+  }>): React$1.ReactNode;
+  <TFieldValues extends FieldValues>(props: Extract<FormErrorMessagePrimitiveProps<TFieldValues>, {
+    type: "root";
+  }>): React$1.ReactNode;
+};
+declare const FormErrorMessagePrimitive: FormErrorMessagePrimitiveType;
+type FormErrorMessageProps<TControl, TFieldValues extends FieldValues> = (TControl extends Control<infer TValues> ? {
+  className?: string;
+  control?: never;
+  errorField?: FieldPath<TValues>;
+  type?: "regular";
+} : {
+  className?: string;
+  control?: Control<TFieldValues>;
+  errorField?: FieldPath<TFieldValues>;
+  type?: "regular";
+}) | {
+  className?: string;
+  control?: never;
+  errorField: string;
+  type: "root";
+};
+declare function FormErrorMessage<TControl, TFieldValues extends FieldValues = FieldValues>(props: FormErrorMessageProps<TControl, TFieldValues>): React$1.JSX.Element;
+type FormSubmitProps = InferProps<"button"> & {
+  asChild?: boolean;
+};
+declare function FormSubmit<TElement extends React$1.ElementType = "button">(props: PolymorphicProps<TElement, FormSubmitProps>): React$1.JSX.Element;
+type GetFieldValue<TFieldPathOrPaths, TFieldValues extends FieldValues> = TFieldPathOrPaths extends Array<FieldPath<TFieldValues>> ? FieldPathValues<TFieldValues, TFieldPathOrPaths> : TFieldPathOrPaths extends FieldPath<TFieldValues> ? FieldPathValue<TFieldValues, TFieldPathOrPaths> : unknown;
+type FormSubscribeToFieldValueRenderFn<TFieldValues extends FieldValues, TFieldPathOrPaths> = (props: {
+  value: GetFieldValue<TFieldPathOrPaths, TFieldValues>;
+}) => React$1.ReactNode;
+type FormSubscribeToFieldValueProps<TFieldValues extends FieldValues, TFieldPathOrPaths> = DiscriminatedRenderProps<FormSubscribeToFieldValueRenderFn<TFieldValues, TFieldPathOrPaths>> & {
+  control: Control<TFieldValues>;
+  name?: TFieldPathOrPaths;
+};
+declare function FormSubscribeToFieldValue<TFieldValues extends FieldValues, const TFieldPathOrPaths extends Array<FieldPath<TFieldValues>> | FieldPath<TFieldValues>>(props: FormSubscribeToFieldValueProps<TFieldValues, TFieldPathOrPaths>): React$1.ReactNode;
+type FormSubscribeToFormStateRenderFn<TFieldValues extends FieldValues> = (props: UseFormStateReturn<TFieldValues>) => React$1.ReactNode;
+type FormSubscribeToFormStateProps<TFieldValues extends FieldValues> = DiscriminatedRenderProps<FormSubscribeToFormStateRenderFn<TFieldValues>> & {
+  control?: Control<TFieldValues>;
+  name?: Array<FieldPath<TFieldValues>> | FieldPath<TFieldValues>;
+};
+declare function FormSubscribeToFormState<TFieldValues extends FieldValues = FieldValues>(props: FormSubscribeToFormStateProps<TFieldValues>): React$1.ReactNode;
+
+//#endregion
+//#region src/components/ui/form/form-parts.d.ts
+declare namespace form_parts_d_exports {
+  export { FormFieldControlledField as ControlledField, FormDescription as Description, FormErrorMessage as ErrorMessage, FormErrorMessagePrimitive as ErrorMessagePrimitive, FormField as Field, FormFieldContext as FieldContext, FormFieldController as FieldController, FormInput as Input, FormInputGroup as InputGroup, FormInputLeftItem as InputLeftItem, FormInputPrimitive as InputPrimitive, FormInputRightItem as InputRightItem, FormLabel as Label, FormRoot as Root, FormSelect as Select, FormSubmit as Submit, FormSubscribeToFieldValue as SubscribeToFieldValue, FormSubscribeToFormState as SubscribeToFormState, FormTextArea as TextArea, FormTextAreaPrimitive as TextAreaPrimitive };
+}
+//#endregion
+export { FieldValues, FormDescription as FormDescription$1, FormErrorMessage as FormErrorMessage$1, FormErrorMessagePrimitive as FormErrorMessagePrimitive$1, FormErrorMessagePrimitiveProps, FormField as FormField$1, FormFieldContext as FormFieldContext$1, FormFieldControlledField as FormFieldControlledField$1, FormFieldController as FormFieldController$1, FormInput as FormInput$1, FormInputGroup as FormInputGroup$1, FormInputLeftItem as FormInputLeftItem$1, FormInputPrimitive as FormInputPrimitive$1, FormInputProps, FormInputRightItem as FormInputRightItem$1, FormLabel as FormLabel$1, FormRoot as FormRoot$1, FormSelect as FormSelect$1, FormSelectPrimitive as FormSelectPrimitive$1, FormSelectProps, FormSubmit as FormSubmit$1, FormSubscribeToFieldValue as FormSubscribeToFieldValue$1, FormSubscribeToFormState as FormSubscribeToFormState$1, FormTextArea as FormTextArea$1, FormTextAreaPrimitive as FormTextAreaPrimitive$1, FormTextAreaProps, form_parts_d_exports, useFormRootContext as useFormRootContext$1, useStrictFormFieldContext as useStrictFormFieldContext$1 };
+//# sourceMappingURL=index-DQ1yFGd2.d.ts.map

package/dist/esm/index-DnaUCh8d.d.ts

@@ -0,0 +1,15 @@
+import * as React from "react";
+import { AnyString } from "@zayne-labs/toolkit-type-helpers";
+
+//#region src/components/common/teleport/teleport.d.ts
+type ValidHtmlTags = keyof HTMLElementTagNameMap;
+type PortalProps = {
+  children: React.ReactNode;
+  insertPosition?: InsertPosition;
+  to: AnyString | HTMLElement | ValidHtmlTags | null;
+};
+declare function Teleport(props: PortalProps): React.ReactPortal | null;
+
+//#endregion
+export { Teleport as Teleport$1 };
+//# sourceMappingURL=index-DnaUCh8d.d.ts.map

package/dist/esm/index-TBkPiipk.d.ts

@@ -0,0 +1,49 @@
+import { __export } from "./chunk-Cl8Af3a2.js";
+import { GetSlotComponentProps } from "./getSlotMap-DA_uhXqU.js";
+import { ErrorBoundaryProps } from "./index-BSJ30pGj.js";
+import { SuspenseWithBoundaryProps } from "./index-CqlM1M0j.js";
+import * as React from "react";
+
+//#region src/components/common/await/await.d.ts
+type RenderPropFn<TValue> = (result: TValue) => React.ReactNode;
+type ChildrenType<TValue> = React.ReactNode | RenderPropFn<TValue>;
+type AwaitRootProps<TValue> = Pick<SuspenseWithBoundaryProps, "errorFallback" | "fallback"> & {
+  asChild?: boolean;
+  children: ChildrenType<TValue>;
+  promise: Promise<TValue>;
+  wrapperVariant?: "all" | "none" | "only-errorBoundary" | "only-suspense";
+};
+declare function AwaitRoot<TValue>(props: AwaitRootProps<TValue>): React.JSX.Element;
+type AwaitSuccessProps<TValue = unknown> = GetSlotComponentProps<"default", ChildrenType<TValue>>;
+declare function AwaitSuccess<TPromiseOrValue, TValue = Awaited<TPromiseOrValue>>(props: Pick<AwaitSuccessProps<TValue>, "children">): React.ReactNode;
+type AwaitPendingProps = GetSlotComponentProps<"pending", React.SuspenseProps["fallback"]>;
+declare const AwaitPending: {
+  (props: Pick<AwaitPendingProps, "children">): React.ReactNode;
+  readonly slotName?: "pending" | undefined;
+  readonly slotSymbol?: symbol;
+};
+type AwaitErrorProps = GetSlotComponentProps<"error", ErrorBoundaryProps["fallback"]>;
+declare const AwaitError: {
+  (props: Pick<AwaitErrorProps, "children"> & {
+    asChild?: boolean;
+  }): React.ReactNode;
+  readonly slotName?: "error" | undefined;
+  readonly slotSymbol?: symbol;
+};
+
+//#endregion
+//#region src/components/common/await/await-parts.d.ts
+declare namespace await_parts_d_exports {
+  export { AwaitError as Error, AwaitPending as Pending, AwaitRoot as Root, AwaitSuccess as Success };
+}
+//#endregion
+//#region src/components/common/await/await-context.d.ts
+type AwaitContextType<TValue = unknown> = {
+  promise: Promise<TValue>;
+  result: TValue;
+};
+declare const useAwaitContext: <TValue>() => AwaitContextType<TValue>;
+
+//#endregion
+export { AwaitError as AwaitError$1, AwaitPending as AwaitPending$1, AwaitRoot as AwaitRoot$1, AwaitSuccess as AwaitSuccess$1, await_parts_d_exports, useAwaitContext as useAwaitContext$1 };
+//# sourceMappingURL=index-TBkPiipk.d.ts.map

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

@@ -1,61 +1,3 @@
-export { a as GetSlotComponentProps, G as GetSlotMapResult, c as createSlotComponent, g as getSlotMap, s as slotComponentSymbol, w as withSlotNameAndSymbol } from '../../getSlotMap-DTkxtGhd.js';
-import * as React$1 from 'react';
-import { UnknownObject, Prettify } from '@zayne-labs/toolkit-type-helpers';
-
-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) => React$1.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[]) => React$1.ReactNode[];
-
-export { type FunctionalComponent, getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent };
+import { GetSlotComponentProps, GetSlotMapResult, createSlotComponent$1 as createSlotComponent, getSlotMap$1 as getSlotMap, slotComponentSymbol$1 as slotComponentSymbol, withSlotNameAndSymbol$1 as withSlotNameAndSymbol } from "../../getSlotMap-DA_uhXqU.js";
+import { FunctionalComponent, getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent } from "../../index-D-j2Cn1J.js";
+export { FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol };

package/dist/esm/lib/utils/index.js

@@ -1,5 +1,4 @@
-export { createSlotComponent, getSlotMap, slotComponentSymbol, withSlotNameAndSymbol } from '../../chunk-N4274N5K.js';
-export { getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent } from '../../chunk-YO5LJ7ZJ.js';
-import '../../chunk-PZ5AY32C.js';
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map
+import { createSlotComponent, getSlotMap, slotComponentSymbol, withSlotNameAndSymbol } from "../../utils-D4YNWj2X.js";
+import { getMultipleSlots$1 as getMultipleSlots, getRegularChildren$1 as getRegularChildren, getSingleSlot$1 as getSingleSlot, matchesAnySlotComponent$1 as matchesAnySlotComponent, matchesSlotComponent$1 as matchesSlotComponent } from "../../getSlot-BIcGgBwN.js";
+
+export { createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol };