@povio/ui 5.0.0-rc.9 → 6.0.0-rc.2

package/dist/useAsyncList-yHz7twsj.js

@@ -0,0 +1,445 @@
+import { useEffect, useReducer, useRef, useState } from "react";
+import { c } from "react/compiler-runtime";
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/data/useListData.mjs
+function $232f8dea1b0a4f2f$export$79c0c687a5963b0a(opts, dispatch) {
+	let { cursor, getKey } = opts;
+	return {
+		setSelectedKeys(selectedKeys) {
+			dispatch((state) => ({
+				...state,
+				selectedKeys
+			}));
+		},
+		addKeysToSelection(selectedKeys) {
+			dispatch((state) => {
+				if (state.selectedKeys === "all") return state;
+				if (selectedKeys === "all") return {
+					...state,
+					selectedKeys: "all"
+				};
+				return {
+					...state,
+					selectedKeys: /* @__PURE__ */ new Set([...state.selectedKeys, ...selectedKeys])
+				};
+			});
+		},
+		removeKeysFromSelection(selectedKeys) {
+			dispatch((state) => {
+				if (selectedKeys === "all") return {
+					...state,
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+				let selection = state.selectedKeys === "all" ? new Set(state.items.map(getKey)) : new Set(state.selectedKeys);
+				for (let key of selectedKeys) selection.delete(key);
+				return {
+					...state,
+					selectedKeys: selection
+				};
+			});
+		},
+		setFilterText(filterText) {
+			dispatch((state) => ({
+				...state,
+				filterText
+			}));
+		},
+		insert(index, ...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, index, ...values));
+		},
+		insertBefore(key, ...values) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey?.(item) === key);
+				if (index === -1) {
+					if (state.items.length === 0) index = 0;
+					else return state;
+				}
+				return $232f8dea1b0a4f2f$var$insert(state, index, ...values);
+			});
+		},
+		insertAfter(key, ...values) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey?.(item) === key);
+				if (index === -1) {
+					if (state.items.length === 0) index = 0;
+					else return state;
+				}
+				return $232f8dea1b0a4f2f$var$insert(state, index + 1, ...values);
+			});
+		},
+		prepend(...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, 0, ...values));
+		},
+		append(...values) {
+			dispatch((state) => $232f8dea1b0a4f2f$var$insert(state, state.items.length, ...values));
+		},
+		remove(...keys) {
+			dispatch((state) => {
+				let keySet = new Set(keys);
+				let items = state.items.filter((item) => !keySet.has(getKey(item)));
+				let selection = "all";
+				if (state.selectedKeys !== "all") {
+					selection = new Set(state.selectedKeys);
+					for (let key of keys) selection.delete(key);
+				}
+				if (cursor == null && items.length === 0) selection = /* @__PURE__ */ new Set();
+				return {
+					...state,
+					items,
+					selectedKeys: selection
+				};
+			});
+		},
+		removeSelectedItems() {
+			dispatch((state) => {
+				if (state.selectedKeys === "all") return {
+					...state,
+					items: [],
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+				let selectedKeys = state.selectedKeys;
+				let items = state.items.filter((item) => !selectedKeys.has(getKey(item)));
+				return {
+					...state,
+					items,
+					selectedKeys: /* @__PURE__ */ new Set()
+				};
+			});
+		},
+		move(key, toIndex) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey(item) === key);
+				if (index === -1) return state;
+				let copy = state.items.slice();
+				let [item] = copy.splice(index, 1);
+				copy.splice(toIndex, 0, item);
+				return {
+					...state,
+					items: copy
+				};
+			});
+		},
+		moveBefore(key, keys) {
+			dispatch((state) => {
+				let toIndex = state.items.findIndex((item) => getKey(item) === key);
+				if (toIndex === -1) return state;
+				return $232f8dea1b0a4f2f$var$move(state, (Array.isArray(keys) ? keys : [...keys]).map((key) => state.items.findIndex((item) => getKey(item) === key)).sort((a, b) => a - b), toIndex);
+			});
+		},
+		moveAfter(key, keys) {
+			dispatch((state) => {
+				let toIndex = state.items.findIndex((item) => getKey(item) === key);
+				if (toIndex === -1) return state;
+				return $232f8dea1b0a4f2f$var$move(state, (Array.isArray(keys) ? keys : [...keys]).map((key) => state.items.findIndex((item) => getKey(item) === key)).sort((a, b) => a - b), toIndex + 1);
+			});
+		},
+		update(key, newValue) {
+			dispatch((state) => {
+				let index = state.items.findIndex((item) => getKey(item) === key);
+				if (index === -1) return state;
+				let updatedValue;
+				if (typeof newValue === "function") updatedValue = newValue(state.items[index]);
+				else updatedValue = newValue;
+				return {
+					...state,
+					items: [
+						...state.items.slice(0, index),
+						updatedValue,
+						...state.items.slice(index + 1)
+					]
+				};
+			});
+		}
+	};
+}
+function $232f8dea1b0a4f2f$var$insert(state, index, ...values) {
+	return {
+		...state,
+		items: [
+			...state.items.slice(0, index),
+			...values,
+			...state.items.slice(index)
+		]
+	};
+}
+function $232f8dea1b0a4f2f$var$move(state, indices, toIndex) {
+	toIndex -= indices.filter((index) => index < toIndex).length;
+	let moves = indices.map((from) => ({
+		from,
+		to: toIndex++
+	}));
+	for (let i = 0; i < moves.length; i++) {
+		let a = moves[i].from;
+		for (let j = i; j < moves.length; j++) if (moves[j].from > a) moves[j].from--;
+	}
+	for (let i = 0; i < moves.length; i++) {
+		let a = moves[i];
+		for (let j = moves.length - 1; j > i; j--) {
+			let b = moves[j];
+			if (b.from < a.to) a.to++;
+			else b.from++;
+		}
+	}
+	let copy = state.items.slice();
+	for (let move of moves) {
+		let [item] = copy.splice(move.from, 1);
+		copy.splice(move.to, 0, item);
+	}
+	return {
+		...state,
+		items: copy
+	};
+}
+//#endregion
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/data/useAsyncList.mjs
+function $c73d3f3d5ec90946$var$reducer(data, action) {
+	let selectedKeys;
+	switch (data.state) {
+		case "idle":
+		case "error": switch (action.type) {
+			case "loading":
+			case "loadingMore":
+			case "sorting":
+			case "filtering": return {
+				...data,
+				filterText: action.filterText ?? data.filterText,
+				state: action.type,
+				items: action.type === "loading" ? [] : data.items,
+				sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+				abortController: action.abortController
+			};
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			case "success":
+			case "error": return data;
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		case "loading":
+		case "sorting":
+		case "filtering": switch (action.type) {
+			case "success":
+				if (action.abortController !== data.abortController) return data;
+				selectedKeys = action.selectedKeys ?? data.selectedKeys;
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: "idle",
+					items: [...action.items ?? []],
+					selectedKeys: selectedKeys === "all" ? "all" : new Set(selectedKeys),
+					sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+					abortController: void 0,
+					cursor: action.cursor
+				};
+			case "error":
+				if (action.abortController !== data.abortController) return data;
+				return {
+					...data,
+					state: "error",
+					error: action.error,
+					abortController: void 0
+				};
+			case "loading":
+			case "loadingMore":
+			case "sorting":
+			case "filtering":
+				data.abortController?.abort("aborting current load and starting new one");
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: action.type,
+					items: action.type === "loading" ? [] : data.items,
+					abortController: action.abortController
+				};
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		case "loadingMore": switch (action.type) {
+			case "success":
+				selectedKeys = data.selectedKeys === "all" || action.selectedKeys === "all" ? "all" : /* @__PURE__ */ new Set([...data.selectedKeys, ...action.selectedKeys ?? []]);
+				return {
+					...data,
+					state: "idle",
+					items: [...data.items, ...action.items ?? []],
+					selectedKeys,
+					sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+					abortController: void 0,
+					cursor: action.cursor
+				};
+			case "error":
+				if (action.abortController !== data.abortController) return data;
+				return {
+					...data,
+					state: "error",
+					error: action.error
+				};
+			case "loading":
+			case "sorting":
+			case "filtering":
+				data.abortController?.abort();
+				return {
+					...data,
+					filterText: action.filterText ?? data.filterText,
+					state: action.type,
+					items: action.type === "loading" ? [] : data.items,
+					abortController: action.abortController
+				};
+			case "loadingMore":
+				action.abortController?.abort();
+				return data;
+			case "update": return {
+				...data,
+				...action.updater?.(data)
+			};
+			default: throw new Error(`Invalid action "${action.type}" in state "${data.state}"`);
+		}
+		default: throw new Error(`Invalid state "${data.state}"`);
+	}
+}
+function $c73d3f3d5ec90946$export$bc3384a35de93d66(options) {
+	const { load, sort, initialSelectedKeys, initialSortDescriptor, getKey = (item) => item.id || item.key, initialFilterText = "" } = options;
+	let [data, dispatch] = useReducer($c73d3f3d5ec90946$var$reducer, {
+		state: "idle",
+		error: void 0,
+		items: [],
+		selectedKeys: initialSelectedKeys === "all" ? "all" : new Set(initialSelectedKeys),
+		sortDescriptor: initialSortDescriptor,
+		filterText: initialFilterText
+	});
+	const dispatchFetch = async (action, fn) => {
+		let abortController = new AbortController();
+		try {
+			dispatch({
+				...action,
+				abortController
+			});
+			let previousFilterText = action.filterText ?? data.filterText;
+			let response = await fn({
+				items: data.items.slice(),
+				selectedKeys: data.selectedKeys,
+				sortDescriptor: action.sortDescriptor ?? data.sortDescriptor,
+				signal: abortController.signal,
+				cursor: action.type === "loadingMore" ? data.cursor : void 0,
+				filterText: previousFilterText,
+				loadingState: data.state
+			});
+			let filterText = response.filterText ?? previousFilterText;
+			dispatch({
+				type: "success",
+				...response,
+				abortController
+			});
+			if (filterText && filterText !== previousFilterText && !abortController.signal.aborted) dispatchFetch({
+				type: "filtering",
+				filterText
+			}, load);
+		} catch (e) {
+			dispatch({
+				type: "error",
+				error: e,
+				abortController
+			});
+		}
+	};
+	let didDispatchInitialFetch = useRef(false);
+	useEffect(() => {
+		if (!didDispatchInitialFetch.current) {
+			dispatchFetch({ type: "loading" }, load);
+			didDispatchInitialFetch.current = true;
+		}
+	}, []);
+	return {
+		items: data.items,
+		selectedKeys: data.selectedKeys,
+		sortDescriptor: data.sortDescriptor,
+		isLoading: data.state === "loading" || data.state === "loadingMore" || data.state === "sorting" || data.state === "filtering",
+		loadingState: data.state,
+		error: data.error,
+		filterText: data.filterText,
+		getItem(key) {
+			return data.items.find((item) => getKey(item) === key);
+		},
+		reload() {
+			dispatchFetch({ type: "loading" }, load);
+		},
+		loadMore() {
+			if (data.state === "loading" || data.state === "loadingMore" || data.state === "filtering" || data.cursor == null) return;
+			dispatchFetch({ type: "loadingMore" }, load);
+		},
+		sort(sortDescriptor) {
+			dispatchFetch({
+				type: "sorting",
+				sortDescriptor
+			}, sort || load);
+		},
+		...$232f8dea1b0a4f2f$export$79c0c687a5963b0a({
+			...options,
+			getKey,
+			cursor: data.cursor
+		}, (fn) => {
+			dispatch({
+				type: "update",
+				updater: fn
+			});
+		}),
+		setFilterText(filterText) {
+			dispatchFetch({
+				type: "filtering",
+				filterText
+			}, load);
+		}
+	};
+}
+//#endregion
+//#region src/hooks/useAsyncList.ts
+function useAsyncList(options) {
+	const $ = c(9);
+	const [hasMore, setHasMore] = useState(false);
+	const sort = options.sort;
+	let t0;
+	if ($[0] !== sort) {
+		t0 = sort ? async (args) => {
+			const result = await sort(args);
+			if (!args.signal.aborted) setHasMore(result.cursor != null);
+			return result;
+		} : void 0;
+		$[0] = sort;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== options || $[3] !== t0) {
+		t1 = {
+			...options,
+			sort: t0,
+			async load(args_0) {
+				const result_0 = await options.load(args_0);
+				if (!args_0.signal.aborted) setHasMore(result_0.cursor != null);
+				return result_0;
+			}
+		};
+		$[2] = options;
+		$[3] = t0;
+		$[4] = t1;
+	} else t1 = $[4];
+	const list = $c73d3f3d5ec90946$export$bc3384a35de93d66(t1);
+	const t2 = list.loadingState === "error" ? list.error : void 0;
+	const t3 = hasMore && list.loadingState !== "error";
+	let t4;
+	if ($[5] !== list || $[6] !== t2 || $[7] !== t3) {
+		t4 = {
+			...list,
+			error: t2,
+			hasMore: t3
+		};
+		$[5] = list;
+		$[6] = t2;
+		$[7] = t3;
+		$[8] = t4;
+	} else t4 = $[8];
+	return t4;
+}
+//#endregion
+export { useAsyncList as t };

package/dist/{useBreakpoint-DQoMN-BG.js → useBreakpoint-DOUmXVZ2.js}

@@ -1,4 +1,4 @@
-import { t as UIConfig } from "./uiConfig.context-BS3r_kTS.js";
+import { t as UIConfig } from "./uiConfig.context-dxsO9puE.js";
 import { useSyncExternalStore } from "react";
 import { c } from "react/compiler-runtime";
 //#region src/hooks/useBreakpoint.ts
@@ -6,10 +6,10 @@ let breakpoints = null;
 function getBreakpoints() {
 	if (breakpoints) return breakpoints;
 	if (typeof window === "undefined") return {
-		sm: "23.75rem",
-		md: "37.5rem",
-		lg: "80rem",
-		xl: "105rem"
+		sm: "40rem",
+		md: "48rem",
+		lg: "64rem",
+		xl: "80rem"
 	};
 	const cs = getComputedStyle(document.documentElement);
 	const entries = [

package/dist/{useControlledState-CzXkZCX8.js → useControlledState-CuU1VIh1.js}

@@ -1,6 +1,6 @@
 import $ahdqC$react, { useCallback, useEffect, useReducer, useRef, useState } from "react";
-//#region ../../node_modules/.bun/react-stately@3.50.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/utils/useControlledState.mjs
-const $3e6197669829fe11$var$useEarlyEffect = typeof document !== "undefined" ? $ahdqC$react["useInsertionEffect"] ?? $ahdqC$react.useLayoutEffect : () => {};
+//#region ../../node_modules/.bun/react-stately@3.51.0+83d5fd7b249dbeef/node_modules/react-stately/dist/private/utils/useControlledState.mjs
+const $3e6197669829fe11$var$useEarlyEffect = typeof document !== "undefined" || parseInt($ahdqC$react.version, 10) >= 19 ? $ahdqC$react["useInsertionEffect"] ?? $ahdqC$react.useLayoutEffect : () => {};
 function $3e6197669829fe11$export$40bfa8c7b0832715(value, defaultValue, onChange) {
 	let [stateValue, setStateValue] = useState(value || defaultValue);
 	let valueRef = useRef(stateValue);

package/dist/useFieldAccessibility-eZIMECmG.js

@@ -0,0 +1,19 @@
+import { useId } from "react";
+//#region src/components/inputs/shared/useFieldAccessibility.ts
+const joinIds = (...ids) => {
+	const uniqueIds = [...new Set(ids.flatMap((id) => id?.split(/\s+/u).filter(Boolean) ?? []))];
+	return uniqueIds.length > 0 ? uniqueIds.join(" ") : void 0;
+};
+const useFieldAccessibility = ({ describedBy, error, helperText }) => {
+	const generatedHelperTextId = useId();
+	const generatedErrorMessageId = useId();
+	const helperTextId = helperText ? `field-helper-${generatedHelperTextId}` : void 0;
+	const errorMessageId = error ? `field-error-${generatedErrorMessageId}` : void 0;
+	return {
+		describedBy: joinIds(describedBy, helperTextId, errorMessageId),
+		errorMessageId,
+		helperTextId
+	};
+};
+//#endregion
+export { useFieldAccessibility as t };

package/dist/{useFilters-XNH27Md2.js → useFilters-HIngImwn.js}

@@ -1,5 +1,5 @@
 import { t as UIRouter } from "./router.context-B4FvsTim.js";
-import { t as RoutingUtils } from "./routing.utils-UTQonIhB.js";
+import { t as RoutingUtils } from "./routing.utils-DfxEt0_Y.js";
 import { useEffect, useState } from "react";
 import { c } from "react/compiler-runtime";
 import { z } from "zod";

package/dist/{form.binding-DVJ5F0JE.d.ts → useForm-I6z23FXf.d.ts}

@@ -13,20 +13,20 @@ type FieldValidators = {
 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"> & {
+type UIForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues> = Omit<TanStackForm<TFieldValues>, "handleSubmit"> & {
   readonly disabled: boolean;
   getFieldValidators: (name: DeepKeys<TFieldValues>) => FieldValidators | undefined;
   notifyBlur: (name: DeepKeys<TFieldValues>) => void;
-  parseValues: (values: TFieldValues) => unknown;
+  parseValues: (values: TFieldValues) => TTransformedValues;
   subscribeBlur: (listener: (name: DeepKeys<TFieldValues>) => void) => () => void;
-  handleSubmit: (onValid: FormSubmitHandler<any>, onInvalid?: FormSubmitErrorHandler<TFieldValues>) => (event?: {
+  handleSubmit: (onValid: FormSubmitHandler<TTransformedValues>, 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> {
+interface BaseUseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
   /** Initial form values. Changes after mount are ignored; use `form.reset()` to replace form values. */
   defaultValues?: NullableDefaults<TFieldValues> | AsyncDefaultValues<TFieldValues>;
   disabled?: boolean;
@@ -36,16 +36,16 @@ interface UseFormProps<TFieldValues, TTransformedValues = TFieldValues> {
   }) => Promise<unknown>;
   zodSchema?: z.ZodType<TTransformedValues, TFieldValues>;
 }
-declare function useForm<TSchema extends z.ZodType<Record<string, unknown>, Record<string, unknown>>, _TContext = unknown>(props: UseFormProps<z.input<TSchema>, z.output<TSchema>> & {
+/** A distinct parsed output requires the schema that produces it. */
+type UseFormProps<TFieldValues, TTransformedValues = TFieldValues> = BaseUseFormProps<TFieldValues, TTransformedValues> & ([TFieldValues] extends [TTransformedValues] ? unknown : {
+  zodSchema: z.ZodType<TTransformedValues, TFieldValues>;
+});
+type UseFormArguments<TFieldValues, TTransformedValues> = [TFieldValues] extends [TTransformedValues] ? [props?: UseFormProps<TFieldValues, TTransformedValues>] : [props: UseFormProps<TFieldValues, TTransformedValues>];
+declare function useForm<TSchema extends z.ZodType<unknown, Record<string, unknown>>>(props: UseFormProps<z.input<NoInfer<TSchema>>, z.output<NoInfer<TSchema>>> & {
   zodSchema: TSchema;
-}): UIForm<z.input<TSchema>>;
-declare function useForm<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;
+}): UIForm<z.input<TSchema>, z.output<TSchema>>;
+declare function useForm<TFieldValues extends Record<string, unknown> = Record<string, unknown>, TTransformedValues = TFieldValues>(...args: UseFormArguments<TFieldValues, TTransformedValues>): UIForm<TFieldValues, TTransformedValues>;
+declare const useFormValue: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues, unknown>, selector: (values: TFieldValues) => TSelected) => TSelected;
+declare const useFormState: <TFieldValues extends Record<string, unknown>, TSelected>(form: UIForm<TFieldValues, unknown>, 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 as u };
+export { UIForm as a, useFormState as c, FormSubmitHandler as i, useFormValue as l, DeepValue as n, UseFormProps as o, FormSubmitErrorHandler as r, useForm as s, DeepKeys as t };