@zayne-labs/ui-react 0.10.5 → 0.10.7

package/dist/esm/getSlot-Cf5ON6lE.js

@@ -1,85 +0,0 @@
-import { AssertionError, isArray, isFunction } from "@zayne-labs/toolkit-type-helpers";
-import { Fragment, isValidElement } from "react";
-import { toArray } from "@zayne-labs/toolkit-core";
-
-//#region src/lib/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;
-	const hasMatchingSlotSymbol = isWithSlotSymbol(resolvedChildType) && isWithSlotSymbol(SlotComponent) && resolvedChildType.slotSymbol === SlotComponent.slotSymbol;
-	if (hasMatchingSlotSymbol) 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) => {
-	const matchesSlot = SlotComponents.some((SlotComponent) => matchesSlotComponent(child, SlotComponent));
-	return matchesSlot;
-};
-/**
-* @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);
-	const shouldThrow = throwOnMultipleSlotMatch && calculateSlotOccurrences(childrenArray, SlotComponent) > 1;
-	if (shouldThrow) throw new AssertionError(errorMessage);
-	const slotElement = childrenArray.find((child) => matchesSlotComponent(child, SlotComponent));
-	return slotElement;
-};
-/**
-* @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
-	}));
-	const regularChildren = getRegularChildren(children, SlotComponents);
-	return {
-		regularChildren,
-		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;
-	const childrenArray = toArray(actualChildren);
-	const regularChildren = childrenArray.filter((child) => !matchesAnySlotComponent(child, toArray(SlotComponentOrComponents)));
-	return regularChildren;
-};
-
-//#endregion
-export { getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent };
-//# sourceMappingURL=getSlot-Cf5ON6lE.js.map

package/dist/esm/getSlot-Cf5ON6lE.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"getSlot-Cf5ON6lE.js","names":["ReactFragment"],"sources":["../../src/lib/utils/getSlot/getSlot.ts"],"sourcesContent":["import { toArray } from \"@zayne-labs/toolkit-core\";\nimport type { InferProps } from \"@zayne-labs/toolkit-react/utils\";\nimport {\n\ttype AnyFunction,\n\tAssertionError,\n\ttype Prettify,\n\ttype UnknownObject,\n\tisArray,\n\tisFunction,\n} from \"@zayne-labs/toolkit-type-helpers\";\nimport { Fragment as ReactFragment, isValidElement } from \"react\";\n\nexport type FunctionalComponent<TProps extends UnknownObject = never> = React.FunctionComponent<TProps>;\n\nconst isWithSlotSymbol = <TFunction extends AnyFunction>(\n\tcomponent: TFunction\n): component is Record<\"slotSymbol\", unknown> & TFunction => {\n\treturn \"slotSymbol\" in component && Boolean(component.slotSymbol);\n};\n\nconst isWithSlotReference = <TFunction extends AnyFunction>(\n\tcomponent: TFunction\n): component is Record<\"slotReference\", unknown> & TFunction => {\n\treturn \"slotReference\" in component && Boolean(component.slotReference);\n};\n/**\n * @description Checks if a react child (within the children array) matches the provided SlotComponent using multiple matching strategies:\n * 1. Matches by slot symbol property\n * 2. Matches by component name\n */\n\nexport const matchesSlotComponent = (child: React.ReactNode, SlotComponent: FunctionalComponent) => {\n\tif (!isValidElement(child) || !isFunction(child.type)) {\n\t\treturn false;\n\t}\n\n\tconst resolvedChildType = isWithSlotReference(child.type)\n\t\t? (child.type.slotReference as FunctionalComponent)\n\t\t: child.type;\n\n\tconst hasMatchingSlotSymbol =\n\t\tisWithSlotSymbol(resolvedChildType)\n\t\t&& isWithSlotSymbol(SlotComponent)\n\t\t&& resolvedChildType.slotSymbol === SlotComponent.slotSymbol;\n\n\tif (hasMatchingSlotSymbol) {\n\t\treturn true;\n\t}\n\n\tif (child.type.name === SlotComponent.name) {\n\t\treturn true;\n\t}\n\n\treturn false;\n};\n\n/**\n * @description Checks if a react child (within the children array) matches any of the provided SlotComponents.\n */\nexport const matchesAnySlotComponent = (child: React.ReactNode, SlotComponents: FunctionalComponent[]) => {\n\tconst matchesSlot = SlotComponents.some((SlotComponent) => matchesSlotComponent(child, SlotComponent));\n\n\treturn matchesSlot;\n};\n\ntype SlotOptions = {\n\t/**\n\t * @description The error message to throw when multiple slots are found for a given slot component\n\t */\n\terrorMessage?: string;\n\t/**\n\t * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component\n\t */\n\tthrowOnMultipleSlotMatch?: boolean;\n};\n\n/**\n * @description Counts how many times a given slot component appears in an array of children\n * @internal\n */\nconst calculateSlotOccurrences = (\n\tchildrenArray: React.ReactNode[],\n\tSlotComponent: FunctionalComponent\n) => {\n\tlet count = 0;\n\n\tfor (const child of childrenArray) {\n\t\tif (!matchesSlotComponent(child, SlotComponent)) continue;\n\n\t\tcount += 1;\n\t}\n\n\treturn count;\n};\n\n/**\n * @description Retrieves a single slot element from a collection of React children that matches the provided SlotComponent component.\n *\n * @throws { AssertionError } when throwOnMultipleSlotMatch is true and multiple slots are found\n */\nexport const getSingleSlot = (\n\tchildren: React.ReactNode,\n\tSlotComponent: FunctionalComponent,\n\toptions: SlotOptions = {}\n) => {\n\tconst {\n\t\terrorMessage = \"Only one instance of the SlotComponent is allowed\",\n\t\tthrowOnMultipleSlotMatch = false,\n\t} = options;\n\n\tconst actualChildren =\n\t\tisValidElement<InferProps<typeof ReactFragment>>(children) && children.type === ReactFragment\n\t\t\t? children.props.children\n\t\t\t: children;\n\n\tconst childrenArray = toArray<React.ReactNode>(actualChildren);\n\n\tconst shouldThrow =\n\t\tthrowOnMultipleSlotMatch && calculateSlotOccurrences(childrenArray, SlotComponent) > 1;\n\n\tif (shouldThrow) {\n\t\tthrow new AssertionError(errorMessage);\n\t}\n\n\tconst slotElement = childrenArray.find((child) => matchesSlotComponent(child, SlotComponent));\n\n\treturn slotElement;\n};\n\n// NOTE -  You can imitate const type parameter by extending readonly[] | []\n\ntype MultipleSlotsOptions = {\n\t/**\n\t * @description The error message to throw when multiple slots are found for a given slot component\n\t * If a string is provided, the same message will be used for all slot components\n\t * If an array is provided, each string in the array will be used as the errorMessage for the corresponding slot component\n\t */\n\terrorMessage?: string | string[];\n\t/**\n\t * @description When true, an AssertionError will be thrown if multiple slots are found for a given slot component\n\t * If a boolean is provided, the same value will be used for all slot components\n\t * If an array is provided, each boolean in the array will be used as the throwOnMultipleSlotMatch value for the corresponding slot component\n\t */\n\tthrowOnMultipleSlotMatch?: boolean | boolean[];\n};\n\ntype GetMultipleSlotsResult<TSlotComponents extends FunctionalComponent[]> = {\n\tregularChildren: React.ReactNode[];\n\tslots: { [Key in keyof TSlotComponents]: ReturnType<TSlotComponents[Key]> };\n};\n\n/**\n * @description The same as getSingleSlot, but for multiple slot components\n */\nexport const getMultipleSlots = <const TSlotComponents extends FunctionalComponent[]>(\n\tchildren: React.ReactNode,\n\tSlotComponents: TSlotComponents,\n\toptions?: MultipleSlotsOptions\n): Prettify<GetMultipleSlotsResult<TSlotComponents>> => {\n\tconst { errorMessage, throwOnMultipleSlotMatch } = options ?? {};\n\n\tconst slots = SlotComponents.map((SlotComponent, index) =>\n\t\tgetSingleSlot(children, SlotComponent, {\n\t\t\terrorMessage: isArray(errorMessage) ? errorMessage[index] : errorMessage,\n\t\t\tthrowOnMultipleSlotMatch: isArray(throwOnMultipleSlotMatch)\n\t\t\t\t? throwOnMultipleSlotMatch[index]\n\t\t\t\t: throwOnMultipleSlotMatch,\n\t\t})\n\t);\n\n\tconst regularChildren = getRegularChildren(children, SlotComponents);\n\n\treturn { regularChildren, slots } as GetMultipleSlotsResult<TSlotComponents>;\n};\n\n/**\n * @description Returns all children that are not slot elements (i.e., don't match any of the provided slot components)\n */\nexport const getRegularChildren = (\n\tchildren: React.ReactNode,\n\tSlotComponentOrComponents: FunctionalComponent | FunctionalComponent[]\n) => {\n\tconst actualChildren =\n\t\tisValidElement<InferProps<typeof ReactFragment>>(children) && children.type === ReactFragment\n\t\t\t? children.props.children\n\t\t\t: children;\n\n\tconst childrenArray = toArray<React.ReactNode>(actualChildren);\n\n\tconst regularChildren = childrenArray.filter(\n\t\t(child) => !matchesAnySlotComponent(child, toArray(SlotComponentOrComponents))\n\t);\n\n\treturn regularChildren;\n};\n"],"mappings":";;;;;AAcA,MAAM,oBACL,cAC4D;AAC5D,QAAO,gBAAgB,aAAa,QAAQ,UAAU;AACtD;AAED,MAAM,uBACL,cAC+D;AAC/D,QAAO,mBAAmB,aAAa,QAAQ,UAAU;AACzD;;;;;;AAOD,MAAa,wBAAwB,OAAwB,kBAAuC;AACnG,KAAI,CAAC,eAAe,UAAU,CAAC,WAAW,MAAM,MAC/C,QAAO;CAGR,MAAM,oBAAoB,oBAAoB,MAAM,QAChD,MAAM,KAAK,gBACZ,MAAM;CAET,MAAM,wBACL,iBAAiB,sBACd,iBAAiB,kBACjB,kBAAkB,eAAe,cAAc;AAEnD,KAAI,sBACH,QAAO;AAGR,KAAI,MAAM,KAAK,SAAS,cAAc,KACrC,QAAO;AAGR,QAAO;AACP;;;;AAKD,MAAa,2BAA2B,OAAwB,mBAA0C;CACzG,MAAM,cAAc,eAAe,MAAM,kBAAkB,qBAAqB,OAAO;AAEvF,QAAO;AACP;;;;;AAiBD,MAAM,4BACL,eACA,kBACI;CACJ,IAAI,QAAQ;AAEZ,MAAK,MAAM,SAAS,eAAe;AAClC,MAAI,CAAC,qBAAqB,OAAO,eAAgB;AAEjD,WAAS;CACT;AAED,QAAO;AACP;;;;;;AAOD,MAAa,iBACZ,UACA,eACA,UAAuB,EAAE,KACrB;CACJ,MAAM,EACL,eAAe,qDACf,2BAA2B,OAC3B,GAAG;CAEJ,MAAM,iBACL,eAAiD,aAAa,SAAS,SAASA,WAC7E,SAAS,MAAM,WACf;CAEJ,MAAM,gBAAgB,QAAyB;CAE/C,MAAM,cACL,4BAA4B,yBAAyB,eAAe,iBAAiB;AAEtF,KAAI,YACH,OAAM,IAAI,eAAe;CAG1B,MAAM,cAAc,cAAc,MAAM,UAAU,qBAAqB,OAAO;AAE9E,QAAO;AACP;;;;AA2BD,MAAa,oBACZ,UACA,gBACA,YACuD;CACvD,MAAM,EAAE,cAAc,0BAA0B,GAAG,WAAW,EAAE;CAEhE,MAAM,QAAQ,eAAe,KAAK,eAAe,UAChD,cAAc,UAAU,eAAe;EACtC,cAAc,QAAQ,gBAAgB,aAAa,SAAS;EAC5D,0BAA0B,QAAQ,4BAC/B,yBAAyB,SACzB;EACH;CAGF,MAAM,kBAAkB,mBAAmB,UAAU;AAErD,QAAO;EAAE;EAAiB;EAAO;AACjC;;;;AAKD,MAAa,sBACZ,UACA,8BACI;CACJ,MAAM,iBACL,eAAiD,aAAa,SAAS,SAASA,WAC7E,SAAS,MAAM,WACf;CAEJ,MAAM,gBAAgB,QAAyB;CAE/C,MAAM,kBAAkB,cAAc,QACpC,UAAU,CAAC,wBAAwB,OAAO,QAAQ;AAGpD,QAAO;AACP"}

package/dist/esm/index-B-NUFudm.d.ts

@@ -1,183 +0,0 @@
-import * as _zayne_labs_toolkit_type_helpers0 from "@zayne-labs/toolkit-type-helpers";
-import { Awaitable, SelectorFn } from "@zayne-labs/toolkit-type-helpers";
-import * as react4 from "react";
-import * as _zayne_labs_toolkit_core0 from "@zayne-labs/toolkit-core";
-import { FileMeta, FileValidationErrorContext, FileValidationHooksAsync, FileValidationSettingsAsync } from "@zayne-labs/toolkit-core";
-import { InferProps, PolymorphicProps } from "@zayne-labs/toolkit-react/utils";
-
-//#region src/components/ui/drop-zone/drop-zone-context.d.ts
-declare const DropZoneStoreContextProvider: (props: {
-    children: React.ReactNode;
-    store: _zayne_labs_toolkit_core0.StoreApi<DropZoneStore>;
-  }) => react4.FunctionComponentElement<react4.ProviderProps<_zayne_labs_toolkit_core0.StoreApi<DropZoneStore> | null>>, useDropZoneStoreContext: <TResult = DropZoneStore>(selector?: _zayne_labs_toolkit_type_helpers0.SelectorFn<DropZoneStore, TResult> | undefined) => TResult;
-//#endregion
-//#region src/components/ui/drop-zone/use-drop-zone.d.ts
-type ExtraProps = {
-  container?: InferProps<HTMLElement>;
-  input?: InferProps<"input">;
-  trigger?: InferProps<"button">;
-};
-type ClassNames = { [key in keyof ExtraProps]: string };
-type UseDropZoneResult = {
-  inputRef: React.RefObject<HTMLInputElement | null>;
-  propGetters: DropZonePropGetters;
-  storeApi: ReturnType<typeof createDropZoneStore>;
-  useDropZoneStore: typeof useDropZoneStoreContext;
-};
-type UseDropZoneProps = FileValidationSettingsAsync & {
-  /**
-   * CSS classes to apply to the various parts of the drop zone
-   */
-  classNames?: ClassNames;
-  /**
-   * Whether to disallow preview for non-image files
-   * @default true
-   */
-  disablePreviewForNonImageFiles?: boolean;
-  /**
-   * Extra props to pass to various parts of the dropzone
-   */
-  extraProps?: ExtraProps;
-  /**
-   * Initial files to populate the drop zone
-   */
-  initialFiles?: FileMeta | FileMeta[] | null;
-  /**
-   * Whether to allow multiple files to be uploaded
-   */
-  multiple?: boolean;
-  /**
-   * Callback function to be called when internal files state changes
-   */
-  onFilesChange?: (context: Pick<DropZoneState, "fileStateArray">) => void;
-  /**
-   * Callback function to be called when new files are uploaded
-   */
-  onUpload?: (context: Pick<DropZoneState, "fileStateArray">) => Awaitable<void>;
-  /**
-   * Callback function to be called on each file upload as they occur
-   */
-  onUploadError?: FileValidationHooksAsync["onError"];
-  /**
-   * Callback function to be called once after all file upload errors have occurred
-   */
-  onUploadErrorCollection?: FileValidationHooksAsync["onErrorCollection"];
-  /**
-   * Callback function to be called on file upload success
-   */
-  onUploadSuccess?: FileValidationHooksAsync["onSuccess"];
-  /**
-   * Whether clicking the drop zone area will open the default file picker or not
-   *
-   * @default true
-   */
-  shouldOpenFilePickerOnAreaClick?: boolean;
-  /**
-   * Custom validation function.
-   *
-   * If the function returns false, the file will be rejected
-   *
-   */
-  validator?: FileValidationSettingsAsync["validator"];
-};
-declare const useDropZone: (props?: UseDropZoneProps) => UseDropZoneResult;
-//#endregion
-//#region src/components/ui/drop-zone/types.d.ts
-type FileState = {
-  /**
-   *  File object or file metadata
-   */
-  file: File | FileMeta;
-  /**
-   *  Unique ID for the file
-   */
-  id: string;
-  /**
-   *  Preview URL for the file
-   *  - Will be undefined if `disallowPreviewForNonImageFiles` is set to `true` and the file is not an image
-   *  - Can also be undefined if `URL.createObjectURL` fails
-   */
-  preview: string | undefined;
-};
-type DropZonePropGetters = {
-  getContainerProps: (containerProps?: ExtraProps["container"]) => ExtraProps["container"];
-  getInputProps: (inputProps?: ExtraProps["input"]) => ExtraProps["input"];
-  getTriggerProps: (triggerProps?: ExtraProps["trigger"]) => ExtraProps["trigger"];
-};
-type DropZoneState = {
-  /**
-   *  List of validation errors
-   */
-  errors: FileValidationErrorContext[];
-  /**
-   *  List of files with their preview URLs and unique IDs
-   */
-  fileStateArray: FileState[];
-  /**
-   *  Whether or not a file is currently being dragged over the drop zone
-   */
-  isDraggingOver: boolean;
-};
-type DropZoneActions = {
-  addFiles: (files: File[] | FileList | null) => Awaitable<void>;
-  clearErrors: () => void;
-  clearFiles: () => void;
-  handleChange: (event: React.ChangeEvent<HTMLInputElement>) => Awaitable<void>;
-  handleDragEnter: (event: React.DragEvent<HTMLElement>) => void;
-  handleDragLeave: (event: React.DragEvent<HTMLElement>) => void;
-  handleDragOver: (event: React.DragEvent<HTMLElement>) => void;
-  handleDrop: (event: React.DragEvent<HTMLElement>) => Awaitable<void>;
-  openFilePicker: () => void;
-  removeFile: (fileToRemoveOrFileId: string | FileState) => void;
-};
-//#endregion
-//#region src/components/ui/drop-zone/drop-zone-store.d.ts
-type DropZoneStore = DropZoneState & {
-  actions: DropZoneActions;
-};
-declare const createDropZoneStore: (initStoreValues: Pick<UseDropZoneProps, "allowedFileTypes" | "disablePreviewForNonImageFiles" | "initialFiles" | "maxFileCount" | "maxFileSize" | "multiple" | "onFilesChange" | "onUpload" | "onUploadError" | "onUploadErrorCollection" | "onUploadSuccess" | "rejectDuplicateFiles" | "validator"> & {
-  inputRef: React.RefObject<HTMLInputElement | null>;
-}) => _zayne_labs_toolkit_core0.StoreApi<DropZoneStore>;
-//#endregion
-//#region src/components/ui/drop-zone/drop-zone.d.ts
-type DropZoneRootProps = UseDropZoneProps & {
-  children: react4.ReactNode;
-};
-declare function DropZoneRoot(props: DropZoneRootProps): react4.JSX.Element;
-type DropZoneContextProps<TSlice> = {
-  children: react4.ReactNode | ((props: TSlice) => react4.ReactNode);
-  selector?: SelectorFn<DropZoneStore, TSlice>;
-};
-declare function DropZoneContext<TSlice = DropZoneStore>(props: DropZoneContextProps<TSlice>): react4.ReactNode;
-type DropZoneContainerProps = ExtraProps["container"] & {
-  asChild?: boolean;
-};
-declare function DropZoneContainer<TElement extends react4.ElementType = "div">(props: PolymorphicProps<TElement, DropZoneContainerProps>): react4.JSX.Element;
-type DropZoneInputProps = ExtraProps["input"] & {
-  asChild?: boolean;
-};
-declare function DropZoneInput(props: DropZoneInputProps): react4.JSX.Element;
-type DropZoneAreaProps<TSlice> = {
-  children: react4.ReactNode | ((props: TSlice) => react4.ReactNode);
-  extraProps?: Pick<ExtraProps, "container" | "input">;
-  selector?: SelectorFn<DropZoneStore, TSlice>;
-};
-declare function DropZoneArea<TSlice = DropZoneStore>(props: DropZoneAreaProps<TSlice>): react4.JSX.Element;
-type DropZoneTriggerProps = ExtraProps["trigger"] & {
-  asChild?: boolean;
-};
-declare function DropZoneTrigger(props: DropZoneTriggerProps): react4.JSX.Element;
-type DropZoneFilePreviewProps = {
-  children: react4.ReactNode | ((props: Pick<DropZoneStore, "actions" | "fileStateArray">) => react4.ReactNode);
-};
-declare function DropZoneFilePreview(props: DropZoneFilePreviewProps): react4.ReactNode;
-type DropZoneErrorPreviewProps = {
-  children: react4.ReactNode | ((props: Pick<DropZoneStore, "actions" | "errors">) => react4.ReactNode);
-};
-declare function DropZoneErrorPreview(props: DropZoneErrorPreviewProps): react4.ReactNode;
-declare namespace drop_zone_parts_d_exports {
-  export { DropZoneArea as Area, DropZoneContainer as Container, DropZoneContext as Context, DropZoneErrorPreview as ErrorPreview, DropZoneFilePreview as FilePreview, DropZoneInput as Input, DropZoneRoot as Root, DropZoneTrigger as Trigger };
-}
-//#endregion
-export { ClassNames, DropZoneArea, DropZoneContainer, DropZoneContext, DropZoneContextProps, DropZoneErrorPreview, DropZoneFilePreview, DropZoneInput, DropZoneRoot, DropZoneRootProps, DropZoneTrigger, ExtraProps, UseDropZoneProps, UseDropZoneResult, drop_zone_parts_d_exports, useDropZone, useDropZoneStoreContext };
-//# sourceMappingURL=index-B-NUFudm.d.ts.map

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

@@ -1,142 +0,0 @@
-import { CallbackFn, EmptyObject, Prettify, UnionToIntersection, UnknownObject } from "@zayne-labs/toolkit-type-helpers";
-import * as react8 from "react";
-
-//#region src/lib/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/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, GetSlotComponentProps, GetSlotMapResult, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol };
-//# sourceMappingURL=index-BNrCAe9Y.d.ts.map

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

@@ -1,20 +0,0 @@
-import { ExtractUnion, Prettify } from "@zayne-labs/toolkit-type-helpers";
-import * as React from "react";
-import { DiscriminatedRenderItemProps, 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> = DiscriminatedRenderItemProps<RenderPropFn<TArrayItem>>;
-type ForProps<TArray> = Prettify<{
-  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;
-//#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, ForRenderProps, ForWithWrapper, getElementList };
-//# sourceMappingURL=index-CnvH74ea.d.ts.map

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

@@ -1,2 +0,0 @@
-import { FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol } from "../../index-BNrCAe9Y.js";
-export { FunctionalComponent, GetSlotComponentProps, GetSlotMapResult, createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol };

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

@@ -1,4 +0,0 @@
-import { createSlotComponent, getSlotMap, slotComponentSymbol, withSlotNameAndSymbol } from "../../utils-ChjmDoRe.js";
-import { getMultipleSlots, getRegularChildren, getSingleSlot, matchesAnySlotComponent, matchesSlotComponent } from "../../getSlot-Cf5ON6lE.js";
-
-export { createSlotComponent, getMultipleSlots, getRegularChildren, getSingleSlot, getSlotMap, matchesAnySlotComponent, matchesSlotComponent, slotComponentSymbol, withSlotNameAndSymbol };

package/dist/esm/show-BabiXbf7.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"show-BabiXbf7.js","names":[],"sources":["../../src/components/common/show/show.tsx","../../src/components/common/show/show-parts.ts"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\nimport { getMultipleSlots } from \"@/lib/utils/getSlot\";\nimport { assert, isFunction } from \"@zayne-labs/toolkit-type-helpers\";\n\ntype ShowProps<TWhen> = {\n\tchildren: React.ReactNode | ((value: TWhen) => React.ReactNode);\n\tfallback?: React.ReactNode;\n\twhen: false | TWhen | null | undefined;\n};\n\nexport function ShowRoot<TWhen>(props: ShowProps<TWhen>) {\n\tconst { children, fallback = null, when } = props;\n\n\tconst resolvedChildren = isFunction(children) ? children(when as TWhen) : children;\n\n\tconst {\n\t\tregularChildren,\n\t\tslots: [contentSlot, fallBackSlot],\n\t} = getMultipleSlots(resolvedChildren, [ShowContent, ShowFallback], {\n\t\terrorMessage: [\n\t\t\t\"Only one <Show.Content> component is allowed\",\n\t\t\t\"Only one <Show.Fallback> or <Show.OtherWise> component is allowed\",\n\t\t],\n\t\tthrowOnMultipleSlotMatch: true,\n\t});\n\n\tif (!when) {\n\t\tassert(\n\t\t\t!(fallBackSlot && fallback),\n\t\t\t\"The fallback prop and <Show.Fallback> cannot be used at the same time.\"\n\t\t);\n\n\t\treturn fallBackSlot ?? fallback;\n\t}\n\n\treturn contentSlot ?? regularChildren;\n}\n\nexport function ShowContent({ children }: { children: React.ReactNode }) {\n\treturn children;\n}\nShowContent.slotSymbol = Symbol(\"show-content\");\n\nexport function ShowFallback({ children }: { children: React.ReactNode }) {\n\treturn children;\n}\nShowFallback.slotSymbol = Symbol(\"show-fallback\");\n","export {\n\tShowContent as Content,\n\tShowFallback as Fallback,\n\tShowFallback as Otherwise,\n\tShowRoot as Root,\n} from \"./show\";\n"],"mappings":";;;;;;AAaA,SAAgB,SAAgB,OAAyB;CACxD,MAAM,EAAE,UAAU,WAAW,MAAM,MAAM,GAAG;CAE5C,MAAM,mBAAmB,WAAW,YAAY,SAAS,QAAiB;CAE1E,MAAM,EACL,iBACA,OAAO,CAAC,aAAa,aAAa,EAClC,GAAG,iBAAiB,kBAAkB,CAAC,aAAa,aAAa,EAAE;EACnE,cAAc,CACb,gDACA,oEACA;EACD,0BAA0B;EAC1B;AAED,KAAI,CAAC,MAAM;AACV,SACC,EAAE,gBAAgB,WAClB;AAGD,SAAO,gBAAgB;CACvB;AAED,QAAO,eAAe;AACtB;AAED,SAAgB,YAAY,EAAE,UAAyC,EAAE;AACxE,QAAO;AACP;AACD,YAAY,aAAa,OAAO;AAEhC,SAAgB,aAAa,EAAE,UAAyC,EAAE;AACzE,QAAO;AACP;AACD,aAAa,aAAa,OAAO"}

package/dist/esm/suspense-with-boundary-CEVORL8K.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"suspense-with-boundary-CEVORL8K.js","names":[],"sources":["../../src/components/common/suspense-with-boundary/suspense-with-boundary.tsx"],"sourcesContent":["import { Suspense } from \"react\";\nimport { ErrorBoundary, type ErrorBoundaryProps } from \"../error-boundary\";\n\nexport type SuspenseWithBoundaryProps = {\n\tchildren: React.ReactNode;\n\terrorFallback?: ErrorBoundaryProps[\"fallback\"];\n\tfallback?: React.ReactNode;\n};\n\nexport function SuspenseWithBoundary(props: SuspenseWithBoundaryProps) {\n\tconst { children, errorFallback, fallback } = props;\n\n\tconst errorBoundaryProps = Boolean(errorFallback) && { fallback: errorFallback };\n\tconst suspenseProps = Boolean(fallback) && { fallback };\n\n\treturn (\n\t\t<ErrorBoundary {...errorBoundaryProps}>\n\t\t\t<Suspense {...suspenseProps}>{children}</Suspense>\n\t\t</ErrorBoundary>\n\t);\n}\n"],"mappings":";;;;;AASA,SAAgB,qBAAqB,OAAkC;CACtE,MAAM,EAAE,UAAU,eAAe,UAAU,GAAG;CAE9C,MAAM,qBAAqB,QAAQ,kBAAkB,EAAE,UAAU,eAAe;CAChF,MAAM,gBAAgB,QAAQ,aAAa,EAAE,UAAU;AAEvD,QACC,oBAAC;EAAc,GAAI;YAClB,oBAAC;GAAS,GAAI;GAAgB;;;AAGhC"}

package/dist/esm/switch-CCMD01Rs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"switch-CCMD01Rs.js","names":[],"sources":["../../src/components/common/switch/switch.tsx","../../src/components/common/switch/switch-parts.ts"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\nimport { getRegularChildren, getSingleSlot } from \"@/lib/utils/getSlot\";\nimport { isFunction } from \"@zayne-labs/toolkit-type-helpers\";\n\ntype ValidSwitchComponentType = React.ReactElement<SwitchMatchProps<unknown>>;\n\ntype SwitchProps = {\n\tchildren: ValidSwitchComponentType | ValidSwitchComponentType[];\n\tvalue?: unknown;\n};\n\nconst defaultValueSymbol = Symbol(\"default-value\");\n\nexport function SwitchRoot(props: SwitchProps) {\n\tconst { children, value = defaultValueSymbol } = props;\n\n\tconst defaultCase = getSingleSlot(children, SwitchDefault, {\n\t\terrorMessage: \"Only one <Switch.Default> component is allowed\",\n\t\tthrowOnMultipleSlotMatch: true,\n\t});\n\n\tconst childrenCasesArray = getRegularChildren(children, SwitchDefault) as ValidSwitchComponentType[];\n\n\tconst matchedCase = childrenCasesArray.find((child) => {\n\t\t// == If value is defaultValueSymbol, match the cases in order like switch(true)\n\t\tif (value === defaultValueSymbol) {\n\t\t\treturn Boolean(child.props.when);\n\t\t}\n\n\t\t// == Otherwise, match the cases like switch(value)\n\t\treturn child.props.when === value;\n\t});\n\n\treturn matchedCase ?? defaultCase;\n}\n\ntype SwitchMatchProps<TWhen> = {\n\tchildren: React.ReactNode | ((value: TWhen) => React.ReactNode);\n\twhen: false | TWhen | null | undefined;\n};\n\nexport function SwitchMatch<TWhen>(props: SwitchMatchProps<TWhen>) {\n\tconst { children, when } = props;\n\n\tconst resolvedChildren = isFunction(children) ? children(when as TWhen) : children;\n\n\treturn resolvedChildren;\n}\n\nexport function SwitchDefault({ children }: { children: React.ReactNode }) {\n\treturn children;\n}\nSwitchDefault.slotSymbol = Symbol(\"switch-default\");\n","export { SwitchDefault as Default, SwitchMatch as Match, SwitchRoot as Root } from \"./switch\";\n"],"mappings":";;;;;;AAcA,MAAM,qBAAqB,OAAO;AAElC,SAAgB,WAAW,OAAoB;CAC9C,MAAM,EAAE,UAAU,QAAQ,oBAAoB,GAAG;CAEjD,MAAM,cAAc,cAAc,UAAU,eAAe;EAC1D,cAAc;EACd,0BAA0B;EAC1B;CAED,MAAM,qBAAqB,mBAAmB,UAAU;CAExD,MAAM,cAAc,mBAAmB,MAAM,UAAU;AAEtD,MAAI,UAAU,mBACb,QAAO,QAAQ,MAAM,MAAM;AAI5B,SAAO,MAAM,MAAM,SAAS;CAC5B;AAED,QAAO,eAAe;AACtB;AAOD,SAAgB,YAAmB,OAAgC;CAClE,MAAM,EAAE,UAAU,MAAM,GAAG;CAE3B,MAAM,mBAAmB,WAAW,YAAY,SAAS,QAAiB;AAE1E,QAAO;AACP;AAED,SAAgB,cAAc,EAAE,UAAyC,EAAE;AAC1E,QAAO;AACP;AACD,cAAc,aAAa,OAAO"}

package/dist/esm/teleport-DfuYOzsj.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"teleport-DfuYOzsj.js","names":[],"sources":["../../src/components/common/teleport/teleport.tsx"],"sourcesContent":["\"use client\";\n\nimport * as React from \"react\";\n\nimport { type AnyString, isString } from \"@zayne-labs/toolkit-type-helpers\";\nimport { useEffect, useState } from \"react\";\nimport { createPortal } from \"react-dom\";\n\ntype ValidHtmlTags = keyof HTMLElementTagNameMap;\n\ntype PortalProps = {\n\tchildren: React.ReactNode;\n\tinsertPosition?: InsertPosition;\n\tto: AnyString | HTMLElement | ValidHtmlTags | null;\n};\n\nfunction Teleport(props: PortalProps) {\n\tconst { children, insertPosition, to } = props;\n\n\tconst [portalContainer, setPortalContainer] = useState<HTMLElement | null>(null);\n\n\t/* eslint-disable react-hooks-extra/no-direct-set-state-in-use-effect -- Allow */\n\n\tuseEffect(() => {\n\t\tif (!to) return;\n\n\t\tif (insertPosition) return;\n\n\t\tconst destination = isString(to) ? document.querySelector<HTMLElement>(to) : to;\n\n\t\tdestination && setPortalContainer(destination);\n\t}, [to, insertPosition]);\n\n\tuseEffect(() => {\n\t\tif (!to) return;\n\n\t\tif (!insertPosition) return;\n\n\t\tconst destination = isString(to) ? document.querySelector<HTMLElement>(to) : to;\n\n\t\tconst tempWrapper = document.createElement(\"div\");\n\t\ttempWrapper.style.display = \"contents\";\n\n\t\tdestination?.insertAdjacentElement(insertPosition, tempWrapper);\n\n\t\tsetPortalContainer(tempWrapper);\n\n\t\treturn () => {\n\t\t\ttempWrapper.remove();\n\t\t};\n\t}, [to, insertPosition]);\n\n\t/* eslint-enable react-hooks-extra/no-direct-set-state-in-use-effect -- Allow */\n\n\treturn portalContainer && createPortal(children, portalContainer);\n}\n\nexport { Teleport };\n"],"mappings":";;;;;AAgBA,SAAS,SAAS,OAAoB;CACrC,MAAM,EAAE,UAAU,gBAAgB,IAAI,GAAG;CAEzC,MAAM,CAAC,iBAAiB,mBAAmB,GAAG,SAA6B;AAI3E,iBAAgB;AACf,MAAI,CAAC,GAAI;AAET,MAAI,eAAgB;EAEpB,MAAM,cAAc,SAAS,MAAM,SAAS,cAA2B,MAAM;AAE7E,iBAAe,mBAAmB;CAClC,GAAE,CAAC,IAAI,eAAe;AAEvB,iBAAgB;AACf,MAAI,CAAC,GAAI;AAET,MAAI,CAAC,eAAgB;EAErB,MAAM,cAAc,SAAS,MAAM,SAAS,cAA2B,MAAM;EAE7E,MAAM,cAAc,SAAS,cAAc;AAC3C,cAAY,MAAM,UAAU;AAE5B,eAAa,sBAAsB,gBAAgB;AAEnD,qBAAmB;AAEnB,eAAa;AACZ,eAAY;EACZ;CACD,GAAE,CAAC,IAAI,eAAe;AAIvB,QAAO,mBAAmB,aAAa,UAAU;AACjD"}

package/dist/esm/utils-ChjmDoRe.js

@@ -1,89 +0,0 @@
-import { isFunction } from "@zayne-labs/toolkit-type-helpers";
-import { Fragment, isValidElement } from "react";
-import { toArray } from "@zayne-labs/toolkit-core";
-
-//#region src/lib/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 isFragment = isValidElement(children) && children.type === Fragment;
-	const actualChildren = isFragment ? 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;
-		const isSlotElement = childType.slotSymbol === slotComponentSymbol && Boolean(childType.slotName ?? child.props.name);
-		if (!isSlotElement) {
-			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
-export { createSlotComponent, getSlotMap, slotComponentSymbol, withSlotNameAndSymbol };
-//# sourceMappingURL=utils-ChjmDoRe.js.map

package/dist/esm/utils-ChjmDoRe.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils-ChjmDoRe.js","names":["slots: Record<string, TSlotComponentProps[\"children\"]> & { default: React.ReactNode[] }","ReactFragment"],"sources":["../../src/lib/utils/getSlotMap/getSlotMap.ts"],"sourcesContent":["import { toArray } from \"@zayne-labs/toolkit-core\";\nimport type { InferProps } from \"@zayne-labs/toolkit-react/utils\";\nimport {\n\ttype CallbackFn,\n\ttype EmptyObject,\n\ttype Prettify,\n\ttype UnionToIntersection,\n\ttype UnknownObject,\n\tisFunction,\n} from \"@zayne-labs/toolkit-type-helpers\";\nimport { Fragment as ReactFragment, isValidElement } from \"react\";\n\ntype GetSlotName<TSlotComponentProps extends GetSlotComponentProps> =\n\tstring extends TSlotComponentProps[\"name\"]\n\t\t? never\n\t\t: \"default\" extends TSlotComponentProps[\"name\"]\n\t\t\t? never\n\t\t\t: TSlotComponentProps[\"name\"];\n\ntype GetSpecificSlotsType<TSlotComponentProps extends GetSlotComponentProps> = {\n\t// This conditional before the remapping will prevent an Indexed Record type from showing up if the props are not passed, enhancing type safety\n\t[TName in keyof TSlotComponentProps as GetSlotName<TSlotComponentProps>]: Extract<\n\t\tTSlotComponentProps[\"children\"],\n\t\tReact.ReactNode\n\t>;\n};\n\n/**\n * Maps slot names to their corresponding children types\n */\nexport type GetSlotMapResult<TSlotComponentProps extends GetSlotComponentProps> = UnionToIntersection<\n\tGetSpecificSlotsType<TSlotComponentProps>\n> & { default: React.ReactNode[] };\n\n/**\n * Symbol used to identify SlotComponent instances\n */\nexport const slotComponentSymbol = Symbol(\"slot-component\");\n\n/**\n * @description Creates a map of named slots from React children. Returns an object mapping slot names to their children,\n * with a default slot for unmatched children.\n *\n * @example\n * ```tsx\n * import { type GetSlotComponentProps, SlotComponent } from \"@zayne-labs/toolkit-react/utils\"\n *\n * type SlotProps = GetSlotComponentProps<\"header\" | \"footer\">;\n *\n * function Parent({ children }: { children: React.ReactNode }) {\n *   const slots = getSlotMap<SlotProps>(children);\n *\n *   return (\n *     <div>\n *       <header>{slots.header}</header>\n *       <main>{slots.default}</main>\n *       <footer>{slots.footer}</footer>\n *     </div>\n *   );\n * }\n * ```\n *\n * Usage:\n * ```tsx\n * <Parent>\n *   <SlotComponent name=\"header\">Header Content</SlotComponent>\n *   <div>Random stuff</div>\n *   <SlotComponent name=\"footer\">Footer Content</SlotComponent>\n * </Parent>\n * ```\n */\nexport const getSlotMap = <TSlotComponentProps extends GetSlotComponentProps>(\n\tchildren: React.ReactNode\n): Prettify<GetSlotMapResult<TSlotComponentProps>> => {\n\tconst slots: Record<string, TSlotComponentProps[\"children\"]> & { default: React.ReactNode[] } = {\n\t\tdefault: [],\n\t};\n\n\tconst isFragment = isValidElement<InferProps<HTMLElement>>(children) && children.type === ReactFragment;\n\n\tconst actualChildren = isFragment ? children.props.children : children;\n\n\tconst childrenArray = toArray<React.ReactNode>(actualChildren);\n\n\tfor (const child of childrenArray) {\n\t\tif (!isValidElement<TSlotComponentProps>(child) || !isFunction(child.type)) {\n\t\t\tslots.default.push(child);\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst childType = child.type as SlotWithNameAndSymbol;\n\n\t\tconst isSlotElement =\n\t\t\tchildType.slotSymbol === slotComponentSymbol && Boolean(childType.slotName ?? child.props.name);\n\n\t\tif (!isSlotElement) {\n\t\t\tslots.default.push(child);\n\t\t\tcontinue;\n\t\t}\n\n\t\tconst slotName = childType.slotName ?? child.props.name;\n\n\t\tif (slotName === \"default\") {\n\t\t\tslots.default.push(child);\n\t\t\tcontinue;\n\t\t}\n\n\t\tslots[slotName] = child;\n\t}\n\n\treturn slots as GetSlotMapResult<TSlotComponentProps>;\n};\n\n/**\n * @description Produce props for the SlotComponent\n *\n * @example\n * ```ts\n * // Pattern One (slot or slots have same children type, which is just React.ReactNode by default)\n * type SlotProps = GetSlotComponentProps<\"header\" | \"content\" | \"footer\">;\n *\n * // Pattern Two (some slots can have different children type)\n * type SlotProps =  GetSlotComponentProps<\"header\", React.ReactNode> | GetSlotComponentProps<\"header\", (renderProp: RenderProp) => React.ReactNode>;\n * ```\n */\nexport type GetSlotComponentProps<\n\tTName extends string = string,\n\tTChildren extends CallbackFn<never, React.ReactNode> | React.ReactNode =\n\t\t| CallbackFn<never, React.ReactNode>\n\t\t| React.ReactNode,\n> = {\n\tchildren: TChildren;\n\t/**\n\t * Name of the slot where content should be rendered\n\t */\n\tname: TName;\n};\n\n/**\n * @description Creates a slot component\n */\nexport const createSlotComponent = <TSlotComponentProps extends GetSlotComponentProps>() => {\n\tconst SlotComponent = (props: TSlotComponentProps) => props.children as React.ReactNode;\n\n\tSlotComponent.slotSymbol = slotComponentSymbol;\n\n\treturn SlotComponent;\n};\n\ntype SlotWithNameAndSymbol<\n\tTSlotComponentProps extends GetSlotComponentProps = GetSlotComponentProps,\n\tTOtherProps extends UnknownObject = EmptyObject,\n> = {\n\t(props: Pick<TSlotComponentProps, \"children\"> & TOtherProps): React.ReactNode;\n\treadonly slotName?: TSlotComponentProps[\"name\"];\n\treadonly slotSymbol?: symbol;\n};\n\nfunction DefaultSlotComponent(props: Pick<GetSlotComponentProps, \"children\">): React.ReactNode {\n\treturn props.children as React.ReactNode;\n}\n\n/**\n * @description Adds a slot symbol and name to a slot component passed in\n */\nexport const withSlotNameAndSymbol = <\n\tTSlotComponentProps extends GetSlotComponentProps,\n\tTOtherProps extends UnknownObject = EmptyObject,\n>(\n\tname: TSlotComponentProps[\"name\"],\n\tSlotComponent: SlotWithNameAndSymbol<TSlotComponentProps, TOtherProps> = DefaultSlotComponent\n) => {\n\t/* eslint-disable no-param-reassign -- This is necessary */\n\t// @ts-expect-error -- This is necessary for the time being, to prevent type errors and accidental overrides on consumer side\n\tSlotComponent.slotSymbol = slotComponentSymbol;\n\t// @ts-expect-error -- This is necessary for the time being, to prevent type errors and accidental overrides on consumer side\n\tSlotComponent.slotName = name;\n\n\t/* eslint-enable no-param-reassign -- This is necessary */\n\n\treturn SlotComponent;\n};\n"],"mappings":";;;;;;;;AAqCA,MAAa,sBAAsB,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkC1C,MAAa,cACZ,aACqD;CACrD,MAAMA,QAA0F,EAC/F,SAAS,EAAE,EACX;CAED,MAAM,aAAa,eAAwC,aAAa,SAAS,SAASC;CAE1F,MAAM,iBAAiB,aAAa,SAAS,MAAM,WAAW;CAE9D,MAAM,gBAAgB,QAAyB;AAE/C,MAAK,MAAM,SAAS,eAAe;AAClC,MAAI,CAAC,eAAoC,UAAU,CAAC,WAAW,MAAM,OAAO;AAC3E,SAAM,QAAQ,KAAK;AACnB;EACA;EAED,MAAM,YAAY,MAAM;EAExB,MAAM,gBACL,UAAU,eAAe,uBAAuB,QAAQ,UAAU,YAAY,MAAM,MAAM;AAE3F,MAAI,CAAC,eAAe;AACnB,SAAM,QAAQ,KAAK;AACnB;EACA;EAED,MAAM,WAAW,UAAU,YAAY,MAAM,MAAM;AAEnD,MAAI,aAAa,WAAW;AAC3B,SAAM,QAAQ,KAAK;AACnB;EACA;AAED,QAAM,YAAY;CAClB;AAED,QAAO;AACP;;;;AA8BD,MAAa,4BAA+E;CAC3F,MAAM,iBAAiB,UAA+B,MAAM;AAE5D,eAAc,aAAa;AAE3B,QAAO;AACP;AAWD,SAAS,qBAAqB,OAAiE;AAC9F,QAAO,MAAM;AACb;;;;AAKD,MAAa,yBAIZ,MACA,gBAAyE,yBACrE;AAGJ,eAAc,aAAa;AAE3B,eAAc,WAAW;AAIzB,QAAO;AACP"}