@povio/ui 3.4.0-rc.9 → 4.0.0-rc.2

package/dist/useTableNav-Tu8UZxHA.d.ts

@@ -0,0 +1,291 @@
+import { n as StyleMergeUtils, t as UIOverrides } from "./uiOverrides.context-C3xb4Ttq.js";
+import { t as FieldPath } from "./form.binding-DVJ5F0JE.js";
+import { n as TypographyProps } from "./Typography-BWmZd20e.js";
+import { CSSProperties, ComponentType, Dispatch, FC, KeyboardEvent, ReactNode, SetStateAction } from "react";
+import { z } from "zod";
+import { CellContext, ColumnDef, ColumnMeta, ColumnOrderState, ColumnVisibilityState, OnChangeFn, PaginationState, Row, RowData, RowSelectionState, SortingState, StockFeatures, Table } from "@tanstack/react-table";
+import { DragEndEvent, UniqueIdentifier } from "@dnd-kit/core";
+import { TFunction } from "i18next";
+//#region src/components/table/CellText.d.ts
+interface CellTextProps extends Partial<Pick<TypographyProps, "variant" | "size">> {
+  children: ReactNode;
+  className?: string;
+  style?: CSSProperties;
+}
+declare const CellText: FC<CellTextProps>;
+//#endregion
+//#region src/components/table/ColumnConfig.d.ts
+type ColumnDef$4<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type VisibilityState$2 = ColumnVisibilityState;
+interface ColumnConfigModalProps<TData extends RowData, TValue> {
+  isOpen: boolean;
+  onClose: () => void;
+  configColumns: ColumnDef$4<TData, TValue>[];
+  visibleColumns: VisibilityState$2;
+  onVisibilityChange: (visibleColumns: VisibilityState$2) => void;
+  onOrderChange: (columnOrder: ColumnOrderState) => void;
+}
+declare function ColumnConfigModal<TData extends RowData, TValue>({ isOpen, onClose, configColumns, visibleColumns, onVisibilityChange, onOrderChange }: ColumnConfigModalProps<TData, TValue>): import("react").JSX.Element | null;
+//#endregion
+//#region src/components/table/HeaderText.d.ts
+interface HeaderTextProps extends Partial<Pick<TypographyProps, "variant" | "size">> {
+  children: ReactNode;
+  className?: string;
+  style?: CSSProperties;
+}
+declare const HeaderText: FC<HeaderTextProps>;
+//#endregion
+//#region src/components/table/table.cva.d.ts
+declare const tableRowDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly alternatingBackground: {
+      readonly even: "even:bg-elevation-fill-inverted-4/5";
+      readonly odd: "odd:bg-elevation-fill-inverted-4/5";
+    };
+  }>;
+};
+type TableRowConfig = NonNullable<typeof tableRowDefinition.config>;
+interface TableRowVariantProps extends UIOverrides.VariantProps<TableRowConfig> {}
+declare const tableHeadRowDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+declare const tableHeadDataDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly hasRightBorder: {
+      readonly true: "border-l border-l-elevation-outline-default-1 border-solid";
+      readonly false: "";
+    };
+  }>;
+};
+declare const tableDataDefinition: {
+  base: string[];
+  config: StyleMergeUtils.Config<{
+    readonly hasRightBorder: {
+      readonly true: "border-l border-l-elevation-outline-default-1";
+      readonly false: "";
+    };
+  }>;
+};
+declare const tableHeaderTextDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+declare const tableCellTextDefinition: {
+  base: string[];
+  config?: StyleMergeUtils.Config<Record<never, never>>;
+};
+//#endregion
+//#region src/components/table/Table.d.ts
+type ColumnDef$3<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type ReactTable<TData extends RowData> = Table<StockFeatures, TData>;
+type Row$1<TData extends RowData> = Row<StockFeatures, TData>;
+type VisibilityState$1 = ColumnVisibilityState;
+type BulkSelectionActionsComponent<T extends RowData> = ComponentType<{
+  table: ReactTable<T>;
+}>;
+interface TableWrapperProps<T extends RowData> extends Omit<TableProps<T>, "columns"> {}
+interface TableProps<T extends RowData> extends TableRowVariantProps {
+  items: T[];
+  columns: ((t: TFunction) => ColumnDef$3<T>[]) | ColumnDef$3<T>[];
+  showCellBorder?: boolean;
+  onRowClick?: (row: T) => void;
+  onDoubleClick?: (row: T) => void;
+  className?: string;
+  sorting?: SortingState;
+  setSorting?: Dispatch<SetStateAction<SortingState>>;
+  columnOrder?: ColumnOrderState;
+  setColumnOrder?: Dispatch<SetStateAction<ColumnOrderState>>;
+  columnVisibility?: VisibilityState$1;
+  setColumnVisibility?: Dispatch<SetStateAction<VisibilityState$1>>;
+  bulkSelectionActions?: BulkSelectionActionsComponent<T>;
+  enableDragDrop?: boolean;
+  onDragEnd?: (event: DragEndEvent) => void;
+  onReorder?: (reorderedItems: T[]) => void;
+  getRowId?: (row: T) => UniqueIdentifier;
+  enableRowSelection?: boolean | ((row: Row$1<T>) => boolean);
+  enableMultiRowSelection?: boolean | ((row: Row$1<T>) => boolean);
+  defaultSelectedRows?: RowSelectionState;
+  onRowSelectionChange?: OnChangeFn<RowSelectionState>;
+}
+declare const Table$1: <T extends RowData>({ items, showCellBorder, columns, onRowClick, onDoubleClick, className, sorting, setSorting, columnOrder, setColumnOrder, columnVisibility, setColumnVisibility, bulkSelectionActions: ActionHeader, enableDragDrop, onDragEnd, onReorder, getRowId, enableRowSelection, enableMultiRowSelection, defaultSelectedRows, onRowSelectionChange, ...props }: TableProps<T>) => import("react").JSX.Element;
+//#endregion
+//#region src/components/table/InfiniteTable.d.ts
+interface InfiniteTableWrapperProps<T extends RowData> extends Omit<InfiniteTableProps<T>, "columns"> {}
+interface InfiniteTableProps<T extends RowData> extends TableProps<T> {
+  hasNextPage: boolean;
+  isFetchingNextPage?: boolean;
+  fetchNextPage: () => void;
+}
+declare const InfiniteTable: <T extends RowData>({ hasNextPage, isFetchingNextPage, fetchNextPage, ...rest }: InfiniteTableProps<T>) => import("react").JSX.Element;
+//#endregion
+//#region src/components/table/PaginatedTable.d.ts
+interface PaginatedTableWrapperProps<T extends RowData> extends Omit<PaginatedTableProps<T>, "columns"> {}
+interface PaginatedTableProps<T extends RowData> extends TableProps<T> {
+  totalItems: number;
+  pagination: PaginationState;
+  setPagination: Dispatch<SetStateAction<PaginationState>>;
+}
+declare const PaginatedTable: <T extends RowData>({ pagination, setPagination, items, totalItems, ...rest }: PaginatedTableProps<T>) => import("react").JSX.Element;
+//#endregion
+//#region src/helpers/dynamicColumns.d.ts
+type NestedTypeFromKey<T, K extends string> = K extends keyof T ? T[K] : K extends `${infer First}.${infer Rest}` ? First extends keyof T ? NestedTypeFromKey<T[First], Rest> : never : never;
+type CellContext$1<TData extends RowData, TValue = unknown> = CellContext<StockFeatures, TData, TValue>;
+type ColumnDef$2<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type ColumnMeta$1<TData extends RowData, TValue = unknown> = ColumnMeta<StockFeatures, TData, TValue>;
+type SchemaType<TSchema extends z.ZodObject<any>> = z.infer<TSchema>;
+type SchemaKey<TSchema extends z.ZodObject<any>> = keyof SchemaType<TSchema>;
+type NestedSchemaKey<TSchema extends z.ZodObject<any>> = FieldPath<SchemaType<TSchema>>;
+type SchemaValue<TSchema extends z.ZodObject<any>> = SchemaType<TSchema>[SchemaKey<TSchema>];
+type ColumnMetaType<TSchema extends z.ZodObject<any>> = ColumnMeta$1<SchemaType<TSchema>, SchemaValue<TSchema>>;
+type GetNestedValueType<TSchema extends z.ZodObject<any>, K extends string> = NestedTypeFromKey<SchemaType<TSchema>, K>;
+type NestedSchemaKeyOrString<TSchema extends z.ZodObject<any>> = NestedSchemaKey<TSchema> | (string & {});
+type DynamicColumnDef<TSchema extends z.ZodObject<any>, TValue = any> = Omit<ColumnDef$2<SchemaType<TSchema>, TValue>, "accessorKey" | "cell"> & {
+  cell?: ((props: CellContext$1<SchemaType<TSchema>, TValue>) => any) | NestedSchemaKey<TSchema>;
+};
+type ColumnsConfig<TSchema extends z.ZodObject<any>> = { [K in NestedSchemaKey<TSchema>]?: DynamicColumnDef<TSchema, GetNestedValueType<TSchema, K>> | ((props: CellContext$1<SchemaType<TSchema>, GetNestedValueType<TSchema, K>>) => any) | NestedSchemaKey<TSchema> | boolean; };
+type CustomColumnDef<TSchema extends z.ZodObject<any>> = Omit<ColumnDef$2<SchemaType<TSchema>, any>, "accessorKey" | "cell"> & {
+  accessorKey?: NestedSchemaKeyOrString<TSchema>;
+  cell?: ((props: CellContext$1<SchemaType<TSchema>, any>) => any) | NestedSchemaKey<TSchema>;
+};
+type CustomColumnsConfig<TSchema extends z.ZodObject<any>> = Record<string, CustomColumnDef<TSchema> | ((props: CellContext$1<SchemaType<TSchema>, undefined>) => any) | NestedSchemaKey<TSchema>>;
+interface DynamicColumnsOptions<TSchema extends z.ZodObject<any>> {
+  columns?: ColumnsConfig<TSchema>;
+  customColumns?: CustomColumnsConfig<TSchema>;
+  order?: NestedSchemaKeyOrString<TSchema>[];
+  sortable?: NestedSchemaKeyOrString<TSchema>[] | z.ZodEnum<any>;
+  disableFormatting?: NestedSchemaKeyOrString<TSchema>[];
+  emptyValue?: ReactNode;
+  namespace?: string;
+  overridePresetLocales?: boolean;
+  globalMeta?: Omit<ColumnMetaType<TSchema>, "sortKey">;
+  globalWrapper?: (children: ReactNode) => ReactNode;
+  includeAll?: boolean;
+}
+interface DynamicColumnsParams<TSchema extends z.ZodObject<any>> {
+  schema: TSchema;
+  preset?: ColumnDef$2<SchemaType<TSchema>>[];
+  options: DynamicColumnsOptions<TSchema>;
+}
+declare const dynamicColumns: <TSchema extends z.ZodObject<any>>({ schema, preset, options }: DynamicColumnsParams<TSchema>) => ColumnDef$2<SchemaType<TSchema>>[];
+//#endregion
+//#region src/hooks/usePagination.d.ts
+declare function usePagination(defaultPagination?: PaginationState): {
+  pagination: PaginationState;
+  setPagination: import("react").Dispatch<import("react").SetStateAction<PaginationState>>;
+  pageIndex: number;
+  pageSize: number;
+};
+//#endregion
+//#region src/hooks/useSorting.d.ts
+declare function useSorting(defaultSorting?: SortingState, prefix?: string): {
+  sorting: SortingState;
+  setSorting: import("react").Dispatch<import("react").SetStateAction<SortingState>>;
+  order: string;
+};
+//#endregion
+//#region src/hooks/useTableColumnConfig.d.ts
+type ColumnDef$1<TData extends RowData, TValue = unknown> = ColumnDef<StockFeatures, TData, TValue>;
+type VisibilityState = ColumnVisibilityState;
+interface UseTableColumnConfigOptions {
+  visibleColumns?: VisibilityState;
+  columnOrder?: ColumnOrderState;
+  onVisibilityChange?: (value: VisibilityState) => void;
+  onOrderChange?: (value: ColumnOrderState) => void;
+}
+declare function useTableColumnConfig<TData extends RowData, TValue>(defaultColumns: ColumnDef$1<TData, TValue>[], options?: UseTableColumnConfigOptions): {
+  configColumns: ColumnDef$1<TData, TValue>[];
+  columns: ColumnDef$1<TData, TValue>[];
+  visibleColumns: ColumnVisibilityState;
+  columnOrder: ColumnOrderState;
+  onVisibilityChange: (value: VisibilityState) => void;
+  onOrderChange: (value: ColumnOrderState) => void;
+};
+//#endregion
+//#region src/hooks/useTableNav.d.ts
+declare const Selectors: {
+  readonly Cell: '[role="cell"],[role="gridcell"],[role="columnheader"],[role="rowheader"],td,th';
+  readonly Row: '[role="row"],tr';
+  readonly RowGroup: '[role="rowgroup"],thead,tbody,tfoot';
+  /** Selector from here: https://github.com/Shopify/polaris/blob/main/polaris-react/src/utilities/focus.ts#L10 */
+  readonly Focusable: 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not([aria-disabled="true"]):not([tabindex="-1"]):not(:disabled),*[tabindex]';
+};
+type Config = {
+  /** Enable debug logs */
+  debug?: boolean;
+  /** CSS Selectors being used to find Rows, Row Groups, Cells and Focusable elements */
+  selectors?: Partial<typeof Selectors>;
+  /** How many rows to move when pressing page up/down - Default goes to first/last row */
+  pageUpDown?: number;
+} | undefined;
+declare class DataGridNav {
+  private selectors;
+  readonly pageUpDown: number | undefined;
+  private keys;
+  private disabled;
+  readonly debug: boolean;
+  private activeCell;
+  constructor();
+  constructor(config: Config);
+  private debugLog;
+  /**
+   * Disables the keyboard listener in cases
+   * that elements inside the grid need to use
+   * arrows keys etc., like select dropdowns
+   */
+  disable(): void;
+  /**
+   * Enables the keyboard listeners
+   */
+  enable(): void;
+  private isFocusable;
+  getActiveCell(): HTMLElement | null;
+  /** Used as a keyboard listener for key up */
+  tableKeyUp(): void;
+  /** Used as a keyboard listener for key down */
+  tableKeyDown(e: KeyboardEvent): void;
+  /**
+   * Handles the navigation inside a cell
+   */
+  cellNavigation(e: KeyboardEvent): void;
+  /**
+   * Handles the navigation outside a cell
+   * on the grid level
+   */
+  gridNavigation(e: KeyboardEvent): void;
+  private pageCellNavigation;
+  private verticalCellNavigation;
+  /**
+   * Sending a row `Element` and then the first cell will be focused.
+   *
+   * If you want to focus the last cell then the row children can be passed in
+   * reversed order
+   */
+  private focusOnFirstCell;
+  /**
+   * Get the column index of a `cell` based on the first `row` parent.
+   * `cellIndex` could be used, but it's not supported in HTML tables.
+   */
+  private getColumnIndex;
+  /**
+   * Get the row index of a `row` based
+   * on its sibling rows
+   */
+  private getRowIndex;
+  /**
+   * Equivalent to prevUntil/nextUntil in jQuery
+   * https://api.jquery.com/prevUntil/
+   */
+  private findUntil;
+}
+declare function useTableNav(options?: Config): {
+  listeners: {
+    onKeyDown: (e: KeyboardEvent) => void;
+    onKeyUp: () => void;
+  };
+  tableNav: DataGridNav;
+};
+//#endregion
+export { HeaderText as C, CellText as D, ColumnConfigModalProps as E, CellTextProps as O, tableRowDefinition as S, ColumnConfigModal as T, tableCellTextDefinition as _, DynamicColumnsOptions as a, tableHeadRowDefinition as b, PaginatedTableProps as c, InfiniteTableProps as d, InfiniteTableWrapperProps as f, TableRowVariantProps as g, TableWrapperProps as h, usePagination as i, PaginatedTableWrapperProps as l, TableProps as m, useTableColumnConfig as n, dynamicColumns as o, Table$1 as p, useSorting as r, PaginatedTable as s, useTableNav as t, InfiniteTable as u, tableDataDefinition as v, HeaderTextProps as w, tableHeaderTextDefinition as x, tableHeadDataDefinition as y };

package/dist/useToast-NBGlVeFP.d.ts

@@ -0,0 +1,16 @@
+import { r as ToastProps } from "./Toast-DIlYlUQk.js";
+import { Id, ToastOptions, ToastPosition } from "react-toastify";
+//#region src/components/status/Toast/useToast.d.ts
+interface ToastParams extends Omit<ToastProps, "color"> {
+  position?: ToastPosition;
+}
+type ToastOptions$1 = Omit<ToastOptions, "position" | "data">;
+declare const useToast: () => {
+  successToast: (params: ToastParams, options?: ToastOptions$1) => Id;
+  errorToast: (params: ToastParams, options?: ToastOptions$1) => Id;
+  warningToast: (params: ToastParams, options?: ToastOptions$1) => Id;
+  neutralToast: (params: ToastParams, options?: ToastOptions$1) => Id;
+  closeToast: (id: Id) => void;
+};
+//#endregion
+export { ToastParams as n, useToast as r, ToastOptions$1 as t };

package/dist/useTranslationMemo-CrZbeyBv.js

@@ -0,0 +1,32 @@
+import { c } from "react/compiler-runtime";
+import { useTranslation } from "react-i18next";
+//#region src/hooks/useTranslationMemo.ts
+function useTranslationMemo(func) {
+	const $ = c(5);
+	const { t } = useTranslation();
+	let t0;
+	bb0: {
+		if (func.length === 1) {
+			let t1;
+			if ($[0] !== func || $[1] !== t) {
+				t1 = func(t);
+				$[0] = func;
+				$[1] = t;
+				$[2] = t1;
+			} else t1 = $[2];
+			t0 = t1;
+			break bb0;
+		}
+		const t1 = func;
+		let t2;
+		if ($[3] !== t1) {
+			t2 = t1();
+			$[3] = t1;
+			$[4] = t2;
+		} else t2 = $[4];
+		t0 = t2;
+	}
+	return t0;
+}
+//#endregion
+export { useTranslationMemo as t };

package/dist/useTranslationMemo-Dy3p6m1g.d.ts

@@ -0,0 +1,6 @@
+import { TFunction } from "i18next";
+//#region src/hooks/useTranslationMemo.d.ts
+type TranslatedFunction<T> = ((t: TFunction) => T) | (() => T);
+declare function useTranslationMemo<T>(func: TranslatedFunction<T>): T;
+//#endregion
+export { useTranslationMemo as t };

package/dist/utils/compound-mapper.d.ts

@@ -0,0 +1,2 @@
+import { r as compoundMapper, t as CompoundMapper } from "../compoundMapper-CMoX98D2.js";
+export { type CompoundMapper, compoundMapper };

package/dist/utils/compound-mapper.js

@@ -0,0 +1,2 @@
+import { t as compoundMapper } from "../compoundMapper-Di3SKZnS.js";
+export { compoundMapper };

package/dist/utils/date-time.d.ts

@@ -0,0 +1,2 @@
+import { t as DateTimeUtils } from "../date-time.utils-Cu9TVj46.js";
+export { DateTimeUtils };

package/dist/utils/date-time.js

@@ -0,0 +1,2 @@
+import { t as DateTimeUtils } from "../date-time.utils-0F9qduim.js";
+export { DateTimeUtils };

package/dist/utils/date.d.ts

@@ -0,0 +1,2 @@
+import { t as DateUtils } from "../date.utils-BoQnMRlF.js";
+export { DateUtils };

package/dist/utils/date.js

@@ -0,0 +1,2 @@
+import { t as DateUtils } from "../date.utils-B8_QF9y6.js";
+export { DateUtils };

package/dist/utils/file.d.ts

@@ -0,0 +1,2 @@
+import { t as FileUtils } from "../file.utils-Crb-mIHs.js";
+export { FileUtils };

package/dist/utils/file.js

@@ -0,0 +1,2 @@
+import { t as FileUtils } from "../file.utils-DqQxnuAm.js";
+export { FileUtils };

package/dist/utils/intl.d.ts

@@ -0,0 +1,2 @@
+import { t as IntlUtils } from "../intl.utils-NaOZUD2G.js";
+export { IntlUtils };

package/dist/utils/intl.js

@@ -0,0 +1,2 @@
+import { t as IntlUtils } from "../intl.utils-zwAFoZ0U.js";
+export { IntlUtils };

package/dist/utils/logger.d.ts

@@ -1,7 +1,2 @@
-export declare const logger: {
-    info: (...args: unknown[]) => void;
-    debug: (...args: unknown[]) => void;
-    warn: (...args: unknown[]) => void;
-    error: (...args: unknown[]) => void;
-    trace: (...args: unknown[]) => void;
-};
+import { t as logger } from "../logger-N35Xhi14.js";
+export { logger };

package/dist/utils/logger.js

@@ -1,19 +1,2 @@
-import log from "loglevel";
-import prefix from "loglevel-plugin-prefix";
-//#region src/utils/logger.ts
-prefix.reg(log);
-prefix.apply(log, {
-	template: "[%t] %l:",
-	timestampFormatter: (date) => {
-		return date.toISOString();
-	}
-});
-var logger = {
-	info: (...args) => log.info(...args),
-	debug: (...args) => log.debug(...args),
-	warn: (...args) => log.warn(...args),
-	error: (...args) => log.error(...args),
-	trace: (...args) => log.trace(...args)
-};
-//#endregion
+import { t as logger } from "../logger-CqZjM-sn.js";
 export { logger };

package/dist/utils/string.d.ts

@@ -0,0 +1,2 @@
+import { t as StringUtils } from "../string.utils-Cj6AB7uZ.js";
+export { StringUtils };

package/dist/utils/string.js

@@ -0,0 +1,2 @@
+import { t as StringUtils } from "../string.utils-BPgv6QwA.js";
+export { StringUtils };

package/dist/utils-D3gCeElo.js

@@ -0,0 +1,145 @@
+import $ahdqC$react, { forwardRef, useCallback, useContext, useMemo, useRef, useState } from "react";
+import { mergeProps } from "react-aria/mergeProps";
+import { mergeRefs } from "react-aria/mergeRefs";
+import { useLayoutEffect as useLayoutEffect$1 } from "react-aria/private/utils/useLayoutEffect";
+import { useObjectRef } from "react-aria/useObjectRef";
+//#region ../../node_modules/.bun/react-aria-components@1.20.0+67f6792bdf102c28/node_modules/react-aria-components/dist/private/utils.mjs
+const $7230ffa83bc0c2cf$export$c62b8e45d58ddad9 = Symbol("default");
+function $7230ffa83bc0c2cf$export$2881499e37b75b9a({ values, children }) {
+	for (let [Context, value] of values) children = /*#__PURE__*/ $ahdqC$react.createElement(Context.Provider, { value }, children);
+	return children;
+}
+function $7230ffa83bc0c2cf$export$4d86445c2cf5e3(props) {
+	let { className, style, children, defaultClassName, defaultChildren, defaultStyle, values, render } = props;
+	return useMemo(() => {
+		let computedClassName;
+		let computedStyle;
+		let computedChildren;
+		if (typeof className === "function") computedClassName = className({
+			...values,
+			defaultClassName
+		});
+		else computedClassName = className;
+		if (typeof style === "function") computedStyle = style({
+			...values,
+			defaultStyle: defaultStyle || {}
+		});
+		else computedStyle = style;
+		if (typeof children === "function") computedChildren = children({
+			...values,
+			defaultChildren
+		});
+		else if (children == null) computedChildren = defaultChildren;
+		else computedChildren = children;
+		return {
+			className: computedClassName ?? defaultClassName,
+			style: computedStyle || defaultStyle ? {
+				...defaultStyle,
+				...computedStyle
+			} : void 0,
+			children: computedChildren ?? defaultChildren,
+			"data-rac": "",
+			render: render ? (props) => render(props, values) : void 0
+		};
+	}, [
+		className,
+		style,
+		children,
+		defaultClassName,
+		defaultChildren,
+		defaultStyle,
+		values,
+		render
+	]);
+}
+function $7230ffa83bc0c2cf$export$c245e6201fed2f75(value, wrap) {
+	return (renderProps) => wrap(typeof value === "function" ? value(renderProps) : value, renderProps);
+}
+function $7230ffa83bc0c2cf$export$fabf2dc03a41866e(context, slot) {
+	let ctx = useContext(context);
+	if (slot === null) return null;
+	if (ctx && typeof ctx === "object" && "slots" in ctx && ctx.slots) {
+		let slotKey = slot || $7230ffa83bc0c2cf$export$c62b8e45d58ddad9;
+		if (!ctx.slots[slotKey]) {
+			let availableSlots = new Intl.ListFormat().format(Object.keys(ctx.slots).map((p) => `"${p}"`));
+			let errorMessage = slot ? `Invalid slot "${slot}".` : "A slot prop is required.";
+			throw new Error(`${errorMessage} Valid slot names are ${availableSlots}.`);
+		}
+		return ctx.slots[slotKey];
+	}
+	return ctx;
+}
+function $7230ffa83bc0c2cf$export$29f1550f4b0d4415(props, ref, context) {
+	let { ref: contextRef, ...contextProps } = $7230ffa83bc0c2cf$export$fabf2dc03a41866e(context, props.slot) || {};
+	let mergedRef = useObjectRef(useMemo(() => mergeRefs(ref, contextRef), [ref, contextRef]));
+	let mergedProps = mergeProps(contextProps, props);
+	if ("style" in contextProps && contextProps.style && "style" in props && props.style) {
+		if (typeof contextProps.style === "function" || typeof props.style === "function") mergedProps.style = (renderProps) => {
+			let contextStyle = typeof contextProps.style === "function" ? contextProps.style(renderProps) : contextProps.style;
+			let defaultStyle = {
+				...renderProps.defaultStyle,
+				...contextStyle
+			};
+			let style = typeof props.style === "function" ? props.style({
+				...renderProps,
+				defaultStyle
+			}) : props.style;
+			return {
+				...defaultStyle,
+				...style
+			};
+		};
+		else mergedProps.style = {
+			...contextProps.style,
+			...props.style
+		};
+	}
+	return [mergedProps, mergedRef];
+}
+function $7230ffa83bc0c2cf$export$9d4c57ee4c6ffdd8(initialState = true) {
+	let [hasSlot, setHasSlot] = useState(initialState);
+	let hasRun = useRef(false);
+	let ref = useCallback((el) => {
+		hasRun.current = true;
+		setHasSlot(!!el);
+	}, []);
+	useLayoutEffect$1(() => {
+		if (!hasRun.current) setHasSlot(false);
+	}, []);
+	return [ref, hasSlot];
+}
+function $7230ffa83bc0c2cf$export$ef03459518577ad4(props) {
+	const prefix = /^(data-.*)$/;
+	let filteredProps = {};
+	for (const prop in props) if (!prefix.test(prop)) filteredProps[prop] = props[prop];
+	return filteredProps;
+}
+function $7230ffa83bc0c2cf$var$DOMElement(ElementType, props, forwardedRef) {
+	let { render, ...otherProps } = props;
+	let elementRef = useRef(null);
+	let ref = useMemo(() => mergeRefs(forwardedRef, elementRef), [forwardedRef, elementRef]);
+	useLayoutEffect$1(() => {
+		if (render) {
+			if (!elementRef.current) console.warn("Ref was not connected to DOM element returned by custom `render` function. Did you forget to pass through or merge the `ref`?");
+			else if (elementRef.current.localName !== ElementType) console.warn(`Unexpected DOM element returned by custom \`render\` function. Expected <${ElementType}>, got <${elementRef.current.localName}>. This may break the component behavior and accessibility.`);
+		}
+	}, [ElementType, render]);
+	let domProps = {
+		...otherProps,
+		ref
+	};
+	if (render) return render(domProps, void 0);
+	return /*#__PURE__*/ $ahdqC$react.createElement(ElementType, domProps);
+}
+const $7230ffa83bc0c2cf$var$domComponentCache = {};
+const $7230ffa83bc0c2cf$export$df3a06d6289f983e = new Proxy({}, { get(target, elementType) {
+	if (typeof elementType !== "string") return void 0;
+	let res = $7230ffa83bc0c2cf$var$domComponentCache[elementType];
+	if (!res) {
+		res = /*#__PURE__*/ forwardRef($7230ffa83bc0c2cf$var$DOMElement.bind(null, elementType));
+		$7230ffa83bc0c2cf$var$domComponentCache[elementType] = res;
+	}
+	return res;
+} });
+//#endregion
+export { $7230ffa83bc0c2cf$export$c245e6201fed2f75 as a, $7230ffa83bc0c2cf$export$ef03459518577ad4 as c, $7230ffa83bc0c2cf$export$9d4c57ee4c6ffdd8 as i, $7230ffa83bc0c2cf$export$fabf2dc03a41866e as l, $7230ffa83bc0c2cf$export$29f1550f4b0d4415 as n, $7230ffa83bc0c2cf$export$c62b8e45d58ddad9 as o, $7230ffa83bc0c2cf$export$4d86445c2cf5e3 as r, $7230ffa83bc0c2cf$export$df3a06d6289f983e as s, $7230ffa83bc0c2cf$export$2881499e37b75b9a as t };

package/dist/x-BD2AijMA.js

@@ -0,0 +1,16 @@
+import { t as createLucideIcon } from "./createLucideIcon-LS26Bb1M.js";
+/**
+* @license lucide-react v1.37.0 - ISC
+*
+* This source code is licensed under the ISC license.
+* See the LICENSE file in the root directory of this source tree.
+*/
+const X = createLucideIcon("x", [["path", {
+	d: "M18 6 6 18",
+	key: "1bl5f8"
+}], ["path", {
+	d: "m6 6 12 12",
+	key: "d8bk6v"
+}]]);
+//#endregion
+export { X as t };

package/dist/zod.utils-DrrPDT9v.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+//#region src/utils/zod.utils.ts
+let ZodUtils;
+(function(_ZodUtils) {
+	const unwrapZodType = _ZodUtils.unwrapZodType = (schemaType) => {
+		let unwrappedType = schemaType;
+		while (unwrappedType instanceof z.ZodNullable || unwrappedType instanceof z.ZodOptional) unwrappedType = unwrappedType.unwrap();
+		return unwrappedType;
+	};
+	_ZodUtils.unwrapToZodObject = (schema) => {
+		const inner = unwrapZodType(schema);
+		if (!(inner instanceof z.ZodObject)) throw new Error("ZodUtils.unwrapToZodObject: expected a Zod object, or optional/nullable wrapping a Zod object.");
+		return inner;
+	};
+	const hasZodObjectProperty = (schemaType, property, type) => {
+		return property in schemaType.shape && schemaType.shape[property] instanceof z.core.$ZodType && unwrapZodType(schemaType.shape[property]) instanceof type;
+	};
+	_ZodUtils.isDateRange = (schemaType) => {
+		const unwrappedType = unwrapZodType(schemaType);
+		return unwrappedType instanceof z.ZodObject && hasZodObjectProperty(unwrappedType, "start", z.ZodISODateTime) && hasZodObjectProperty(unwrappedType, "end", z.ZodISODateTime);
+	};
+})(ZodUtils || (ZodUtils = {}));
+//#endregion
+export { ZodUtils as t };