@povio/ui 3.4.0-rc.2 → 3.4.0-rc.20

package/dist/dynamicInputs-D8j0ko24.js

@@ -0,0 +1,194 @@
+import { f as ZodISODateTime, i as ZodEnum, l as ZodString, n as ZodBoolean, o as ZodNumber, r as ZodEmail, s as ZodObject, t as ZodArray, u as ZodUUID } from "./schemas-BkfyFvBp.js";
+import { t as StringUtils } from "./string.utils-BPgv6QwA.js";
+import { t as ZodUtils } from "./zod.utils-Nz_Tbo_v.js";
+import i18next from "i18next";
+//#region src/helpers/dynamicInputs.ts
+const defaultComponentTypes = {
+	datetime: "datePicker",
+	dateRange: "dateRangePicker",
+	boolean: "toggle",
+	number: "numberInput",
+	enum: "select",
+	string: "textInput",
+	email: "textInput",
+	object: "unknown",
+	array: "select",
+	uuid: "select",
+	unknown: "unknown"
+};
+const ZOD_TYPE_COMPONENT_TYPE = [
+	[ZodBoolean, defaultComponentTypes.boolean],
+	[ZodNumber, defaultComponentTypes.number],
+	[ZodEnum, defaultComponentTypes.enum],
+	[ZodISODateTime, defaultComponentTypes.datetime],
+	[ZodString, defaultComponentTypes.string],
+	[ZodEmail, defaultComponentTypes.email],
+	[ZodObject, defaultComponentTypes.object],
+	[ZodArray, defaultComponentTypes.array],
+	[ZodUUID, defaultComponentTypes.uuid]
+];
+const DEFAULT_NAMESPACE = "dynamicInputs";
+const sortInputDefs = (inputDefs, orderKeys) => {
+	if (!orderKeys) return inputDefs;
+	return inputDefs.sort((a, b) => {
+		const orderMap = new Map(orderKeys.map((key, index) => [key, index]));
+		const orderA = orderMap.get(a.name);
+		const orderB = orderMap.get(b.name);
+		if (orderA !== void 0 && orderB !== void 0) return orderA - orderB;
+		if (orderA !== void 0 && orderB === void 0) return -1;
+		if (orderA === void 0 && orderB !== void 0) return 1;
+		return 0;
+	});
+};
+const excludeEntries = (entries) => {
+	return entries.filter(([, value]) => value !== false && value !== void 0);
+};
+const inputConfigToObjectDefinition = (value) => {
+	if (typeof value === "object") return value;
+	if (typeof value === "function") return { render: value };
+	return {};
+};
+const convertInputsConfigToObjectDefinitions = (entries) => {
+	return entries.map(([key, value]) => {
+		return [key, inputConfigToObjectDefinition(value)];
+	});
+};
+const getDefaultInputComponentType = (schemaType) => {
+	if (ZodUtils.isDateRange(schemaType)) return defaultComponentTypes.dateRange;
+	const unwrappedType = ZodUtils.unwrapZodType(schemaType);
+	const componentType = ZOD_TYPE_COMPONENT_TYPE.find(([zodType]) => unwrappedType instanceof zodType)?.[1];
+	if (componentType) return componentType;
+	return defaultComponentTypes.unknown;
+};
+const getDefaultSelectionItems = (keyType) => {
+	const unwrappedType = ZodUtils.unwrapZodType(keyType instanceof ZodArray ? keyType.element : keyType);
+	if (unwrappedType instanceof ZodEnum) return Object.values(unwrappedType.options).filter((value) => typeof value === "string").map((value) => ({
+		id: value,
+		label: StringUtils.capitalize(value)
+	}));
+	return [];
+};
+const getDefaultSelectionMode = (keyType) => {
+	return keyType instanceof ZodArray ? "multiple" : "single";
+};
+const getDefaultProps = (componentType, keyType) => {
+	const props = {};
+	const unwrappedType = ZodUtils.unwrapZodType(keyType);
+	if ([
+		"select",
+		"autocomplete",
+		"segment"
+	].includes(componentType)) props.items = getDefaultSelectionItems(unwrappedType);
+	if ([
+		"select",
+		"querySelect",
+		"autocomplete",
+		"queryAutocomplete",
+		"segment"
+	].includes(componentType)) props.selectionMode = getDefaultSelectionMode(unwrappedType);
+	return props;
+};
+const getLabelAndPlaceholder = (value, options, schemaKey) => {
+	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+	const stringKey = String(schemaKey);
+	let { label, placeholder } = value;
+	if (!label) {
+		const key = `${namespace}.${stringKey}.label`;
+		const translation = i18next.exists(key) ? i18next.t(key) : null;
+		label = typeof translation === "string" ? translation : StringUtils.capitalize(stringKey);
+	}
+	if (!placeholder) {
+		const key = `${namespace}.${stringKey}.placeholder`;
+		const translation = i18next.exists(key) ? i18next.t(key) : null;
+		placeholder = typeof translation === "string" ? translation : void 0;
+	}
+	return {
+		label,
+		placeholder
+	};
+};
+const overridePresetLabelsAndPlaceholders = (presetInputDefs, options) => {
+	const namespace = options.namespace ?? DEFAULT_NAMESPACE;
+	return presetInputDefs.map((inputDef) => {
+		const labelName = String(inputDef.name);
+		const labelKey = `${namespace}.${labelName}.label`;
+		const placeholderKey = `${namespace}.${labelName}.placeholder`;
+		const labelTranslation = i18next.exists(labelKey) ? i18next.t(labelKey) : null;
+		const placeholderTranslation = i18next.exists(placeholderKey) ? i18next.t(placeholderKey) : null;
+		return {
+			...inputDef,
+			label: typeof labelTranslation === "string" ? labelTranslation : inputDef.label,
+			placeholder: typeof placeholderTranslation === "string" ? placeholderTranslation : inputDef.placeholder
+		};
+	});
+};
+const removeOverriddenPresetInputs = (presetInputs, options) => {
+	if (presetInputs.length === 0) return presetInputs;
+	const usedKeys = new Set(Object.keys(options.inputs ?? {}).map(String));
+	return presetInputs.filter((input) => !usedKeys.has(String(input.name)));
+};
+const validateParams = (schema, presetInputs, options) => {
+	const { inputs, order, includeAll } = options;
+	if (!order) return;
+	const inputKeys = Object.keys(inputs ?? {});
+	const presetKeys = presetInputs.map((input) => input.name).filter((name) => name !== void 0);
+	const schemaKeys = includeAll ? Object.keys(schema.shape) : [];
+	const allInputKeys = /* @__PURE__ */ new Set([
+		...inputKeys,
+		...presetKeys,
+		...schemaKeys
+	]);
+	const unnecessaryOrderKeys = order.filter((key) => !allInputKeys.has(key));
+	if (unnecessaryOrderKeys.length > 0) throw new Error(`Found unnecessary keys in "order": [${unnecessaryOrderKeys.join(", ")}]. These keys are not found in any of the input definitions.\nAll defined input keys are: [${Array.from(allInputKeys).join(", ")}].\nIn the case of a preset input definition, the key is the name attribute.`);
+};
+const populateInputDef = (schema, schemaKey, value, options) => {
+	const name = String(schemaKey);
+	const { label, placeholder } = getLabelAndPlaceholder(value, options, schemaKey);
+	const inputWrapper = value.inputWrapper ?? options.globalInputWrapper;
+	if ("render" in value) return {
+		name,
+		label,
+		placeholder,
+		render: value.render
+	};
+	const schemaKeyType = schema.shape[schemaKey];
+	const componentType = "type" in value ? value.type : getDefaultInputComponentType(schemaKeyType);
+	const props = {
+		...componentType ? getDefaultProps(componentType, schemaKeyType) : {},
+		...options.globalProps,
+		...value.props
+	};
+	return {
+		type: componentType === "unknown" ? null : componentType,
+		name,
+		label,
+		placeholder,
+		inputWrapper,
+		props
+	};
+};
+const addMissingSchemaFields = (schema, existingInputDefs, options) => {
+	const schemaFields = Object.keys(schema.shape);
+	const definedFields = new Set(existingInputDefs.map((def) => def.name));
+	const additionalInputDefs = schemaFields.filter((field) => !definedFields.has(field)).map((field) => {
+		return populateInputDef(schema, field, {}, options);
+	});
+	return [...existingInputDefs, ...additionalInputDefs];
+};
+function dynamicInputs({ schema: rawSchema, preset = [], options }) {
+	const schema = ZodUtils.unwrapToZodObject(rawSchema);
+	const objectOptions = options;
+	validateParams(schema, preset, objectOptions);
+	let entries = Object.entries(objectOptions.inputs ?? {});
+	entries = excludeEntries(entries);
+	const inputDefs = convertInputsConfigToObjectDefinitions(entries).map(([key, value]) => {
+		return populateInputDef(schema, key, value, objectOptions);
+	});
+	let presetInputDefs = removeOverriddenPresetInputs(preset, objectOptions);
+	if (objectOptions.overridePresetLocales) presetInputDefs = overridePresetLabelsAndPlaceholders(presetInputDefs, objectOptions);
+	const mergedInputDefs = [...presetInputDefs, ...inputDefs];
+	const allInputDefs = objectOptions.includeAll ? addMissingSchemaFields(schema, mergedInputDefs, objectOptions) : mergedInputDefs;
+	return sortInputDefs(allInputDefs, objectOptions.order);
+}
+//#endregion
+export { getDefaultInputComponentType as n, dynamicInputs 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/fieldAdapter-C_3uizcT.js

@@ -0,0 +1,61 @@
+import { t as UIConfig } from "./uiConfig.context-SBtRegKv.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/file-upload-DDIJKLW8.d.ts

@@ -0,0 +1,10 @@
+import { n as FileUploadBaseProps } from "./fileUpload.types-CQkPqELk.js";
+import "./FileUpload-CHgnF4Nm.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-CQkPqELk.d.ts

@@ -0,0 +1,106 @@
+import { a as DropZoneProps, o as FileTriggerProps } from "./types-BV15_DBT.js";
+import { r as ButtonProps } from "./Button-C_FOjIn-.js";
+import { n as FieldValues } from "./form.binding-DWlFTecs.js";
+import { t as ControlProps } from "./form.types-B9Vp8q2g.js";
+import { n as FormFieldProps } from "./FormField-FvutosEE.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/form.binding-DWlFTecs.d.ts

@@ -0,0 +1,47 @@
+import { f as ZodType } from "./schemas-CAtYiHoz.js";
+import { DeepKeys, DeepValue, ReactFormExtendedApi } from "@tanstack/react-form";
+//#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?: ZodType<TTransformedValues, TFieldValues>;
+}
+declare function useForm$1<TFieldValues extends Record<string, unknown> = Record<string, unknown>, _TContext = unknown, TTransformedValues = TFieldValues>({ defaultValues, disabled, mode, onSubmitAsync, zodSchema }?: 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-DyZ4fH8l.js

@@ -0,0 +1,34 @@
+import { jsx } from "react/jsx-runtime";
+//#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 }) {
+	return /* @__PURE__ */ jsx(form.Field, {
+		name,
+		validators: form.getFieldValidators(name),
+		children: (field) => render({
+			field: {
+				disabled: form.disabled,
+				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 { FieldController as t };

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

@@ -0,0 +1,13 @@
+import { a as DeepValue, c as UIForm, i as DeepKeys } from "./form.binding-DWlFTecs.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/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/hooks/use-filters.d.ts

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

package/dist/hooks/use-filters.js

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

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

@@ -0,0 +1,2 @@
+import { t as useLocalStorage } from "../useLocalStorage-kcEdRxqC.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 };