@povio/ui 3.4.0-rc.4 → 3.4.0-rc.41

package/dist/fieldAdapter-C2YfWBmM.js

@@ -0,0 +1,61 @@
+import { t as UIConfig } from "./uiConfig.context-BG4jfp9p.js";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+import { Controller } from "react-hook-form";
+//#region src/rhf/entry.utils.tsx
+const runtime = (component) => component;
+const useFireBlurOnChange = (props, key) => {
+	const $ = c(3);
+	const config = UIConfig.useConfig();
+	const t0 = props.fireBlurOnChange ?? config[key].fireBlurOnChange;
+	let t1;
+	if ($[0] !== props || $[1] !== t0) {
+		t1 = {
+			...props,
+			fireBlurOnChange: t0
+		};
+		$[0] = props;
+		$[1] = t0;
+		$[2] = t1;
+	} else t1 = $[2];
+	return t1;
+};
+//#endregion
+//#region src/rhf/fieldAdapter.tsx
+function renderRHFField(Component, props, valueKey = "value", blurValueTransform = (value) => value) {
+	if (!("formControl" in props)) {
+		const { fireBlurOnChange, ...componentProps } = props;
+		const runtimeProps = componentProps;
+		return /* @__PURE__ */ jsx(Component, {
+			...runtimeProps,
+			onChange: (value) => {
+				runtimeProps.onChange?.(value);
+				if (fireBlurOnChange) runtimeProps.onBlur?.({ target: { value: blurValueTransform(value) } });
+			}
+		});
+	}
+	const { fireBlurOnChange, formControl, ...componentProps } = props;
+	const runtimeProps = componentProps;
+	return /* @__PURE__ */ jsx(Controller, {
+		control: formControl.control,
+		name: formControl.name,
+		render: ({ field, fieldState }) => {
+			const valueProps = { [valueKey]: field.value ?? (valueKey === "isSelected" ? false : null) };
+			return /* @__PURE__ */ jsx(Component, {
+				...componentProps,
+				...valueProps,
+				ref: field.ref,
+				onChange: (value) => {
+					field.onChange(value ?? null);
+					if (fireBlurOnChange) field.onBlur();
+				},
+				onBlur: field.onBlur,
+				isDisabled: field.disabled || runtimeProps.isDisabled,
+				isDirty: fieldState.isDirty,
+				error: runtimeProps.error ?? fieldState.error?.message
+			});
+		}
+	});
+}
+//#endregion
+export { runtime as n, useFireBlurOnChange as r, renderRHFField as t };

package/dist/fieldAdapter-C4sDFC8f.d.ts

@@ -0,0 +1,9 @@
+import "./form.types-ZNGbcqJS.js";
+import { ComponentType, ReactNode } from "react";
+import { FieldValues } from "react-hook-form";
+//#region src/rhf/fieldAdapter.d.ts
+interface FireBlurOnChangeProps {
+  fireBlurOnChange?: boolean;
+}
+//#endregion
+export { FireBlurOnChangeProps as t };

package/dist/file-upload-Ba6NwH0N.d.ts

@@ -0,0 +1,10 @@
+import { n as FileUploadBaseProps } from "./fileUpload.types-ZUblxJUi.js";
+import "./FileUpload-Czof_aOb.js";
+import { t as ControlProps } from "./form.types-ZNGbcqJS.js";
+import { FieldValues } from "react-hook-form";
+//#region src/entries/rhf/file-upload.d.ts
+type FileUploadProps<T extends FieldValues> = ControlProps<FileUploadBaseProps, T>;
+type RHFFileUploadProps<T extends FieldValues> = FileUploadProps<T>;
+declare const FileUpload: <T extends FieldValues>(props: FileUploadProps<T>) => import("react").ReactNode;
+//#endregion
+export { FileUploadProps as n, RHFFileUploadProps as r, FileUpload as t };

package/dist/file.utils-Crb-mIHs.d.ts

@@ -0,0 +1,21 @@
+//#region src/utils/file.utils.d.ts
+type ResponseHeaders = Headers | Record<string, unknown>;
+type BlobResponse = {
+  data: Blob;
+  headers?: ResponseHeaders;
+};
+declare namespace FileUtils {
+  const extractContentDispositionFilename: (headers?: ResponseHeaders) => string | undefined;
+  const getObjectUrl: (data: Blob | BlobResponse, revokeTimeoutMs?: number) => string;
+  const openFile: (data: Blob | BlobResponse, target?: string, revokeTimeoutMs?: number) => void;
+  const downloadFile: (data: Blob | BlobResponse, fileName?: string, revokeTimeoutMs?: number) => void;
+  const isFileTypeAccepted: (file: File, fileTypes?: readonly string[] | string[]) => boolean;
+  const getCalculatedFileSize: (file?: File) => string;
+  const getFileDisplaySize: (state: {
+    file?: File;
+    displaySize?: number;
+  }) => string;
+  const formatBytes: (size: number, decimals?: number) => string;
+}
+//#endregion
+export { FileUtils as t };

package/dist/file.utils-DqQxnuAm.js

@@ -0,0 +1,61 @@
+//#region src/utils/file.utils.ts
+const isBlobResponse = (data) => !(data instanceof Blob);
+const getHeader = (headers, name) => {
+	if (!headers) return;
+	if (headers instanceof Headers) return headers.get(name) ?? void 0;
+	const matchingKey = Object.keys(headers).find((key) => key.toLowerCase() === name.toLowerCase());
+	const value = matchingKey ? headers[matchingKey] : void 0;
+	return typeof value === "string" ? value : void 0;
+};
+let FileUtils;
+(function(_FileUtils) {
+	const extractContentDispositionFilename = _FileUtils.extractContentDispositionFilename = (headers) => {
+		const contentDisposition = getHeader(headers, "content-disposition");
+		return contentDisposition ? /filename=["']?([^"';]+)/iu.exec(contentDisposition)?.[1] : void 0;
+	};
+	const getObjectUrl = _FileUtils.getObjectUrl = (data, revokeTimeoutMs = 4e4) => {
+		const url = URL.createObjectURL(isBlobResponse(data) ? data.data : data);
+		setTimeout(() => URL.revokeObjectURL(url), revokeTimeoutMs);
+		return url;
+	};
+	_FileUtils.openFile = (data, target = "_blank", revokeTimeoutMs) => {
+		const url = getObjectUrl(data, revokeTimeoutMs);
+		window.open(url, target);
+	};
+	_FileUtils.downloadFile = (data, fileName, revokeTimeoutMs) => {
+		const url = getObjectUrl(data, revokeTimeoutMs);
+		const contentDispositionFileName = isBlobResponse(data) ? extractContentDispositionFilename(data.headers) : void 0;
+		const a = document.createElement("a");
+		a.download = fileName ?? contentDispositionFileName ?? "download";
+		a.rel = "noopener";
+		a.href = url;
+		setTimeout(() => a.dispatchEvent(new MouseEvent("click")));
+	};
+	_FileUtils.isFileTypeAccepted = (file, fileTypes) => {
+		if (!fileTypes || fileTypes.length === 0) return true;
+		return fileTypes.some((type) => {
+			if (type.includes("/")) return file.type === type || type.endsWith("/*") && file.type.startsWith(type.slice(0, -1));
+			return file.name.toLowerCase().endsWith(type.toLowerCase());
+		});
+	};
+	const getCalculatedFileSize = _FileUtils.getCalculatedFileSize = (file) => {
+		if (!file) return "";
+		if (file.size < 1024) return `${file.size} B`;
+		if (file.size < 1048576) return `${(file.size / 1024).toFixed(2)} KB`;
+		if (file.size < 1073741824) return `${(file.size / 1024 / 1024).toFixed(2)} MB`;
+		return `${(file.size / 1024 / 1024 / 1024).toFixed(2)} GB`;
+	};
+	_FileUtils.getFileDisplaySize = (state) => {
+		if (state.file) return getCalculatedFileSize(state.file);
+		if (state.displaySize != null) return formatBytes(state.displaySize);
+		return "";
+	};
+	const formatBytes = _FileUtils.formatBytes = (size, decimals = 2) => {
+		if (size < 1024) return `${size} B`;
+		if (size < 1048576) return `${(size / 1024).toFixed(decimals)} KB`;
+		if (size < 1073741824) return `${(size / 1024 / 1024).toFixed(decimals)} MB`;
+		return `${(size / 1024 / 1024 / 1024).toFixed(decimals)} GB`;
+	};
+})(FileUtils || (FileUtils = {}));
+//#endregion
+export { FileUtils as t };

package/dist/fileUpload.types-ZUblxJUi.d.ts

@@ -0,0 +1,106 @@
+import { a as DropZoneProps, o as FileTriggerProps } from "./types-ZbFfCz06.js";
+import { r as ButtonProps } from "./Button-D0M9lMOR.js";
+import { n as FieldValues } from "./form.binding-Cu03pQ8Y.js";
+import { t as ControlProps } from "./form.types-qEwMTXTZ.js";
+import { n as FormFieldProps } from "./FormField-Iy2O8A4g.js";
+import { ReactNode, Ref } from "react";
+//#region src/types/error-handling.d.ts
+type GeneralErrorCodes = "DATA_VALIDATION_ERROR" | "NETWORK_ERROR" | "CANCELED_ERROR" | "INTERNAL_ERROR" | "UNKNOWN_ERROR";
+declare class ApplicationException<CodeT> extends Error {
+  code: CodeT;
+  serverMessage: string | null;
+  constructor(message: string, code: CodeT, serverMessage: string | null);
+}
+//#endregion
+//#region src/components/inputs/File/fileUpload.types.d.ts
+interface FileUploadVariant {
+  variant?: "vertical" | "horizontal";
+}
+interface SingleFileUploadProps {
+  allowsMultiple?: false;
+  value?: FileUploadState | null;
+  onChange?: (file: File | null) => void;
+  defaultValue?: File | null;
+  onInvalidFileType?: (filename: string) => void;
+}
+interface MultipleFileUploadProps {
+  allowsMultiple: true;
+  value?: FileUploadState[];
+  onChange?: (files: File[]) => void;
+  defaultValue?: File[];
+  onInvalidFileType?: (filenames: string[]) => void;
+}
+type GroupedFileUploadProps = MultipleFileUploadProps | SingleFileUploadProps;
+type GroupedFileUploadControlProps<TFieldValues extends FieldValues> = ({
+  allowsMultiple: true;
+} & ControlProps<MultipleFileUploadProps, TFieldValues>) | ({
+  allowsMultiple?: false;
+} & ControlProps<SingleFileUploadProps, TFieldValues>);
+interface FileUploadResponse {
+  id: string;
+}
+interface FileUploadRequest {
+  data: {
+    resourceName: string;
+    fileName: string;
+    fileSize: number;
+    method: string;
+  };
+}
+interface DefaultFile {
+  name: string;
+  size: number;
+  type?: string;
+  id?: string;
+}
+interface FileUploadCallbacks {
+  fileUpload?: (request: FileUploadRequest, file: File, options?: {
+    abortController?: AbortController;
+    onUploadProgress?: ({ loaded, total }: {
+      loaded: number;
+      total: number;
+    }) => void;
+  }) => Promise<FileUploadResponse>;
+  fileRemove?: ({ id }: {
+    id: string;
+  }) => Promise<void>;
+}
+type FileUploadError = ApplicationException<GeneralErrorCodes>;
+interface FileUploadState {
+  state: "idle" | "uploading" | "uploaded" | "error";
+  file?: File;
+  displayName?: string;
+  displaySize?: number;
+  displayType?: string;
+  src?: string;
+  id?: string;
+  progress?: number;
+  error?: FileUploadError;
+  abortController?: AbortController;
+}
+interface FileUploadContainerChildrenProps {
+  files: FileUploadState[];
+  onRemove: (id: string) => void;
+  onCancel: (index: number) => void;
+}
+type FileUploadButtonProps = Omit<ButtonProps, "children" | "isDisabled" | "isSelected" | "onPress" | "toggle">;
+type FileUploadBaseProps = {
+  as?: "button" | "link";
+  ref?: Ref<HTMLElement>;
+  label?: string;
+  className?: string;
+  emptyText?: string;
+  uploadText?: string;
+  browseText?: string;
+  value?: FileUploadState[];
+  defaultState?: DefaultFile[];
+  clearOnSuccess?: boolean;
+  children?: (props: FileUploadContainerChildrenProps) => ReactNode;
+  listRenderer?: (props: FileUploadContainerChildrenProps) => ReactNode;
+  browseButtonProps?: FileUploadButtonProps;
+  cancelButtonProps?: FileUploadButtonProps;
+} & FormFieldProps & FileUploadVariant & Omit<FileTriggerProps, "children" | "onSelect" | "allowsMultiple" | "value"> & Omit<DropZoneProps, "children" | "onDrop" | "value"> & GroupedFileUploadProps & FileUploadCallbacks;
+type FileUploadProps<TFieldValues extends FieldValues = FieldValues> = FileUploadBaseProps & GroupedFileUploadControlProps<TFieldValues>;
+type FileUploadContainerProps = (Omit<FileUploadBaseProps, "label" | "hideLabel" | "variant" | "as"> & SingleFileUploadProps) | (Omit<FileUploadBaseProps, "label" | "hideLabel" | "variant" | "as"> & MultipleFileUploadProps);
+//#endregion
+export { FileUploadError as a, FileUploadResponse as c, FileUploadContainerProps as i, FileUploadState as l, FileUploadBaseProps as n, FileUploadProps as o, FileUploadButtonProps as r, FileUploadRequest as s, DefaultFile as t };

package/dist/focusWithoutScrolling-DEPiLwKq.js

@@ -0,0 +1,49 @@
+//#region ../../node_modules/.bun/@react-aria+utils@3.33.0+67f6792bdf102c28/node_modules/@react-aria/utils/dist/focusWithoutScrolling.mjs
+function $7215afc6de606d6b$export$de79e2c695e052f3(element) {
+	if ($7215afc6de606d6b$var$supportsPreventScroll()) element.focus({ preventScroll: true });
+	else {
+		let scrollableElements = $7215afc6de606d6b$var$getScrollableElements(element);
+		element.focus();
+		$7215afc6de606d6b$var$restoreScrollPosition(scrollableElements);
+	}
+}
+let $7215afc6de606d6b$var$supportsPreventScrollCached = null;
+function $7215afc6de606d6b$var$supportsPreventScroll() {
+	if ($7215afc6de606d6b$var$supportsPreventScrollCached == null) {
+		$7215afc6de606d6b$var$supportsPreventScrollCached = false;
+		try {
+			document.createElement("div").focus({ get preventScroll() {
+				$7215afc6de606d6b$var$supportsPreventScrollCached = true;
+				return true;
+			} });
+		} catch {}
+	}
+	return $7215afc6de606d6b$var$supportsPreventScrollCached;
+}
+function $7215afc6de606d6b$var$getScrollableElements(element) {
+	let parent = element.parentNode;
+	let scrollableElements = [];
+	let rootScrollingElement = document.scrollingElement || document.documentElement;
+	while (parent instanceof HTMLElement && parent !== rootScrollingElement) {
+		if (parent.offsetHeight < parent.scrollHeight || parent.offsetWidth < parent.scrollWidth) scrollableElements.push({
+			element: parent,
+			scrollTop: parent.scrollTop,
+			scrollLeft: parent.scrollLeft
+		});
+		parent = parent.parentNode;
+	}
+	if (rootScrollingElement instanceof HTMLElement) scrollableElements.push({
+		element: rootScrollingElement,
+		scrollTop: rootScrollingElement.scrollTop,
+		scrollLeft: rootScrollingElement.scrollLeft
+	});
+	return scrollableElements;
+}
+function $7215afc6de606d6b$var$restoreScrollPosition(scrollableElements) {
+	for (let { element, scrollTop, scrollLeft } of scrollableElements) {
+		element.scrollTop = scrollTop;
+		element.scrollLeft = scrollLeft;
+	}
+}
+//#endregion
+export { $7215afc6de606d6b$export$de79e2c695e052f3 as t };

package/dist/form.binding-Cu03pQ8Y.d.ts

@@ -0,0 +1,50 @@
+import { DeepKeys, DeepValue, ReactFormExtendedApi } from "@tanstack/react-form";
+import { z } from "zod";
+//#region src/hooks/useForm.d.ts
+type FormMode = "all" | "onBlur" | "onChange" | "onSubmit" | "onTouched";
+type FieldValidators = {
+  onBlur?: ({ value }: {
+    value: unknown;
+  }) => string | undefined;
+  onChange?: ({ value }: {
+    value: unknown;
+  }) => string | undefined;
+};
+type FormSubmitHandler<TValues> = (values: TValues) => void | Promise<void>;
+type FormSubmitErrorHandler<TValues> = (errors: unknown, values: TValues) => unknown;
+type TanStackForm<TFieldValues> = ReactFormExtendedApi<TFieldValues, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, never>;
+type UIForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>> = Omit<TanStackForm<TFieldValues>, "handleSubmit"> & {
+  readonly disabled: boolean;
+  getFieldValidators: (name: DeepKeys<TFieldValues>) => FieldValidators | undefined;
+  notifyBlur: (name: DeepKeys<TFieldValues>) => void;
+  parseValues: (values: TFieldValues) => unknown;
+  subscribeBlur: (listener: (name: DeepKeys<TFieldValues>) => void) => () => void;
+  handleSubmit: (onValid: FormSubmitHandler<any>, onInvalid?: FormSubmitErrorHandler<TFieldValues>) => (event?: {
+    preventDefault?: () => void;
+    stopPropagation?: () => void;
+  }) => Promise<void>;
+};
+type AsyncDefaultValues<TFieldValues> = (payload?: unknown) => Promise<TFieldValues>;
+type NullableDefaults<T> = T extends Date | File | Blob ? T : T extends Array<infer TItem> ? Array<NullableDefaults<TItem>> : T extends object ? { [K in keyof T]?: NullableDefaults<T[K]> | null; } : T | null;
+interface UseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
+  defaultValues?: NullableDefaults<TFieldValues> | AsyncDefaultValues<TFieldValues>;
+  disabled?: boolean;
+  mode?: FormMode;
+  onSubmitAsync?: (props: {
+    value: TFieldValues;
+  }) => Promise<unknown>;
+  zodSchema?: z.ZodType<TTransformedValues, TFieldValues>;
+}
+declare function useForm$1<TSchema extends z.ZodType<Record<string, unknown>, Record<string, unknown>>, _TContext = unknown>(props: UseFormProps<z.input<TSchema>, z.output<TSchema>> & {
+  zodSchema: TSchema;
+}): UIForm<z.input<TSchema>>;
+declare function useForm$1<TFieldValues extends Record<string, unknown> = Record<string, unknown>, _TContext = unknown, TTransformedValues = TFieldValues>(props?: UseFormProps<TFieldValues, TTransformedValues>): UIForm<TFieldValues>;
+declare const useFormValue: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues>, selector: (values: TFieldValues) => TSelected) => TSelected;
+declare const useFormState: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues>, selector: (state: UIForm<TFieldValues>["state"]) => TSelected) => TSelected;
+//#endregion
+//#region src/components/inputs/shared/form.binding.d.ts
+type FieldValues = Record<string, any>;
+type FieldPath<TFieldValues extends FieldValues> = DeepKeys<TFieldValues>;
+type FormInstance<TFieldValues extends FieldValues> = UIForm<TFieldValues>;
+//#endregion
+export { DeepValue as a, UIForm as c, useFormState as d, useFormValue as f, DeepKeys as i, UseFormProps as l, FieldValues as n, FormSubmitErrorHandler as o, FormInstance as r, FormSubmitHandler as s, FieldPath as t, useForm$1 as u };

package/dist/form.binding-DLKteDiq.js

@@ -0,0 +1,157 @@
+import { useEffect, useLayoutEffect, useMemo, useRef } from "react";
+import { c } from "react/compiler-runtime";
+import { jsx } from "react/jsx-runtime";
+import { useForm, useStore } from "@tanstack/react-form";
+import { Store } from "@tanstack/store";
+//#region src/hooks/useForm.ts
+const disabledStores = /* @__PURE__ */ new WeakMap();
+function useForm$1({ defaultValues, disabled = false, mode = "onSubmit", onSubmitAsync, zodSchema } = {}) {
+	const submitHandlerRef = useRef(() => void 0);
+	const submitErrorHandlerRef = useRef(void 0);
+	const blurListenersRef = useRef(/* @__PURE__ */ new Set());
+	const fieldValidators = useMemo(() => {
+		return /* @__PURE__ */ new Map();
+	}, [mode, zodSchema]);
+	const formValidator = useMemo(() => {
+		if (!zodSchema) return;
+		return ({ value }) => {
+			const result = zodSchema.safeParse(value);
+			if (result.success) return;
+			return { fields: Object.fromEntries(result.error.issues.map((issue) => [pathToString(issue.path), issue.message])) };
+		};
+	}, [zodSchema]);
+	const form = useForm({
+		defaultValues: (typeof defaultValues === "function" ? {} : defaultValues) ?? {},
+		validators: formValidator || onSubmitAsync ? {
+			onSubmit: formValidator,
+			onSubmitAsync
+		} : void 0,
+		onSubmit: async ({ value: value_0 }) => {
+			const transformed = zodSchema ? zodSchema.parse(value_0) : value_0;
+			await submitHandlerRef.current(transformed);
+		},
+		onSubmitInvalid: ({ value: value_1, formApi }) => {
+			submitErrorHandlerRef.current?.(formApi.state.errors, value_1);
+		}
+	});
+	const originalHandleSubmit = useMemo(() => form.handleSubmit.bind(form), [form]);
+	const disabledStoreRef = useRef(void 0);
+	disabledStoreRef.current ??= new Store(disabled);
+	const disabledStore = disabledStoreRef.current;
+	const uiForm = form;
+	Object.defineProperty(uiForm, "disabled", {
+		configurable: true,
+		value: disabled,
+		writable: true
+	});
+	disabledStores.set(uiForm, disabledStore);
+	uiForm.getFieldValidators = (name) => {
+		const cached = fieldValidators.get(name);
+		if (cached || fieldValidators.has(name)) return cached;
+		const schema = zodSchema ? getSchemaAtPath(zodSchema, name) : void 0;
+		if (!schema || mode === "onSubmit") {
+			fieldValidators.set(name, void 0);
+			return;
+		}
+		const validate = ({ value: value_2 }) => {
+			const result_0 = schema.safeParse(value_2);
+			return result_0.success ? void 0 : result_0.error.issues[0]?.message;
+		};
+		const validators = mode === "onChange" || mode === "all" ? { onChange: validate } : { onBlur: validate };
+		fieldValidators.set(name, validators);
+		return validators;
+	};
+	uiForm.notifyBlur = (name_0) => {
+		for (const listener of blurListenersRef.current) listener(name_0);
+	};
+	uiForm.parseValues = (values) => zodSchema ? zodSchema.parse(values) : values;
+	uiForm.subscribeBlur = (listener_0) => {
+		blurListenersRef.current.add(listener_0);
+		return () => blurListenersRef.current.delete(listener_0);
+	};
+	uiForm.handleSubmit = (onValid, onInvalid) => async (event) => {
+		event?.preventDefault?.();
+		event?.stopPropagation?.();
+		submitHandlerRef.current = onValid;
+		submitErrorHandlerRef.current = onInvalid;
+		await originalHandleSubmit();
+	};
+	useEffect(() => {
+		if (typeof defaultValues === "function") defaultValues().then((values_0) => form.reset(values_0));
+	}, [defaultValues, form]);
+	useLayoutEffect(() => {
+		if (disabledStore.state !== disabled) disabledStore.setState(() => disabled);
+	}, [disabled, disabledStore]);
+	return uiForm;
+}
+const useFormDisabled = (form) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== form) {
+		t0 = disabledStores.get(form);
+		$[0] = form;
+		$[1] = t0;
+	} else t0 = $[1];
+	const store = t0;
+	if (!store) throw new Error("useFormDisabled must be used with a form created by useForm");
+	return useStore(store);
+};
+const useFormValue = (form, selector) => {
+	const $ = c(2);
+	let t0;
+	if ($[0] !== selector) {
+		t0 = (state) => selector(state.values);
+		$[0] = selector;
+		$[1] = t0;
+	} else t0 = $[1];
+	return useStore(form.store, t0);
+};
+const useFormState = (form, selector) => {
+	return useStore(form.store, selector);
+};
+const getSchemaAtPath = (rootSchema, path) => {
+	let schema = rootSchema;
+	for (const segment of parsePath(path)) {
+		while (schema?.unwrap && !schema.shape && !schema.element && !schema.items) schema = schema.unwrap();
+		schema = typeof segment === "number" ? schema?.element ?? schema?.items?.[segment] : schema?.shape?.[segment];
+		if (!schema) return;
+	}
+	return schema;
+};
+const parsePath = (path) => path.replaceAll("[", ".").replaceAll("]", "").split(".").filter(Boolean).map((segment) => /^\d+$/.test(segment) ? Number(segment) : segment);
+const pathToString = (path) => path.reduce((result, segment) => typeof segment === "number" ? `${result}[${segment}]` : result ? `${result}.${String(segment)}` : String(segment), "");
+//#endregion
+//#region src/components/inputs/shared/form.types.ts
+const getFieldError = (errors) => errors.flatMap((error) => {
+	if (typeof error === "string") return [error];
+	if (error && typeof error === "object" && "message" in error) return [String(error.message)];
+	return [];
+}).at(0);
+//#endregion
+//#region src/components/inputs/shared/form.binding.tsx
+function FieldController({ control: form, name, render }) {
+	const isFormDisabled = useFormDisabled(form);
+	return /* @__PURE__ */ jsx(form.Field, {
+		name,
+		validators: form.getFieldValidators(name),
+		children: (field) => render({
+			field: {
+				disabled: isFormDisabled,
+				name: field.name,
+				onBlur: () => {
+					field.handleBlur();
+					form.notifyBlur(name);
+				},
+				onChange: field.handleChange,
+				ref: () => void 0,
+				value: field.state.value
+			},
+			fieldState: {
+				error: getFieldError(field.state.meta.errors) ? { message: getFieldError(field.state.meta.errors) } : void 0,
+				isDirty: field.state.meta.isDirty
+			}
+		})
+	});
+}
+//#endregion
+export { useFormValue as i, useForm$1 as n, useFormState as r, FieldController as t };

package/dist/form.types-ZNGbcqJS.d.ts

@@ -0,0 +1,13 @@
+import { Control, FieldPath, FieldPathValue, FieldValues } from "react-hook-form";
+//#region src/rhf/form.types.d.ts
+type ControlKeys<TProps, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = TValueProp | "onChange" | "onBlur";
+interface FormControl<TFieldValues extends FieldValues, TType> {
+  control: Control<TFieldValues>;
+  name: { [K in FieldPath<TFieldValues>]: FieldPathValue<TFieldValues, K> extends TType ? K : never; }[FieldPath<TFieldValues>];
+}
+type FormControlProps<TProps, TFieldValues extends FieldValues, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = {
+  formControl: FormControl<TFieldValues, TProps[TValueProp] | null>;
+} & Omit<TProps, ControlKeys<TProps, TValueProp>> & Partial<Record<ControlKeys<TProps, TValueProp>, never>>;
+type ControlProps<TProps, TFieldValues extends FieldValues, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = FormControlProps<TProps, TFieldValues, TValueProp> | TProps;
+//#endregion
+export { FormControl as n, ControlProps as t };

package/dist/form.types-qEwMTXTZ.d.ts

@@ -0,0 +1,13 @@
+import { a as DeepValue, c as UIForm, i as DeepKeys } from "./form.binding-Cu03pQ8Y.js";
+//#region src/components/inputs/shared/form.types.d.ts
+type ControlKeys<TProps, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = TValueProp | "onChange" | "onBlur";
+interface FormControl<TFieldValues extends Record<string, unknown>, TType> {
+  form: UIForm<TFieldValues>;
+  name: { [K in DeepKeys<TFieldValues>]: DeepValue<TFieldValues, K> extends TType ? K : never; }[DeepKeys<TFieldValues>];
+}
+type FormControlProps<TProps, TFieldValues extends Record<string, unknown>, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = {
+  field: FormControl<TFieldValues, TProps[TValueProp] | null>;
+} & Omit<TProps, ControlKeys<TProps, TValueProp>> & Partial<Record<ControlKeys<TProps, TValueProp>, never>>;
+type ControlProps<TProps, TFieldValues extends Record<string, unknown>, TValueProp extends keyof TProps = "value" extends keyof TProps ? "value" : never> = FormControlProps<TProps, TFieldValues, TValueProp> | TProps;
+//#endregion
+export { ControlProps as t };

package/dist/hooks/use-filters.d.ts

@@ -0,0 +1,2 @@
+import { n as useFilters, t as FilterStore } from "../useFilters-BxRScJdn.js";
+export { type FilterStore, useFilters };

package/dist/hooks/use-filters.js

@@ -0,0 +1,2 @@
+import { t as useFilters } from "../useFilters-20jpzc29.js";
+export { useFilters };

package/dist/hooks/use-local-storage.d.ts

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

package/dist/hooks/use-local-storage.js

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

package/dist/hooks/use-translation-memo.d.ts

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

package/dist/hooks/use-translation-memo.js

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