@noxickon/onyx 5.0.2 → 6.0.0

package/dist/graphql/executors/apolloMutationExecutor.js

@@ -0,0 +1,36 @@
+import { formErrors as e } from "../../hooks/useForm/useForm.js";
+import { defaultExtractErrors as t } from "./graphqlErrors.js";
+//#region src/graphql/executors/apolloMutationExecutor.ts
+function n(n, r) {
+	let { client: i, context: a, extractErrors: o = t, variables: s = (e) => ({ input: e }), ...c } = r;
+	return async ({ payload: t, signal: r }) => {
+		let l = a?.fetchOptions ?? {}, u;
+		try {
+			u = await i.mutate({
+				mutation: n,
+				variables: s(t),
+				...c,
+				context: {
+					...a,
+					fetchOptions: {
+						...l,
+						signal: r
+					}
+				}
+			});
+		} catch (t) {
+			let n = o(t);
+			if (n) return e(n);
+			throw t;
+		}
+		let d = u.error;
+		if (d != null) {
+			let t = o(d);
+			if (t) return e(t);
+			throw d instanceof Error ? d : /* @__PURE__ */ Error("GraphQL mutation failed");
+		}
+		return u.data;
+	};
+}
+//#endregion
+export { n as apolloMutationExecutor };

package/dist/graphql/executors/apolloMutationExecutor.types.d.ts

@@ -0,0 +1,7 @@
+import { ApolloClient } from '@apollo/client';
+import { OxFormDataErrors } from '../../internal/hooks';
+export type ApolloMutationExecutorOptions<TForm extends object, TResult = unknown> = Omit<ApolloClient.MutateOptions<TResult>, 'mutation' | 'variables'> & {
+    client: ApolloClient;
+    extractErrors?: (error: unknown) => OxFormDataErrors<TForm> | null;
+    variables?: (payload: TForm) => Record<string, unknown>;
+};

package/dist/graphql/executors/apolloQueryExecutor.d.ts

@@ -0,0 +1,4 @@
+import { DocumentNode } from 'graphql';
+import { OxExecutor } from '../../hooks';
+import { ApolloQueryExecutorOptions } from './apolloQueryExecutor.types';
+export declare function apolloQueryExecutor<TForm extends object, TResult = unknown>(query: DocumentNode, options: ApolloQueryExecutorOptions<TForm, TResult>): OxExecutor<TForm, TResult>;

package/dist/graphql/executors/apolloQueryExecutor.js

@@ -0,0 +1,37 @@
+import { formErrors as e } from "../../hooks/useForm/useForm.js";
+import { defaultExtractErrors as t } from "./graphqlErrors.js";
+//#region src/graphql/executors/apolloQueryExecutor.ts
+function n(n, r) {
+	let { client: i, context: a, extractErrors: o = t, fetchPolicy: s = "network-only", variables: c = (e) => ({ input: e }), ...l } = r;
+	return async ({ payload: t, signal: r }) => {
+		let u = a?.fetchOptions ?? {}, d;
+		try {
+			d = await i.query({
+				query: n,
+				variables: c(t),
+				fetchPolicy: s,
+				...l,
+				context: {
+					...a,
+					fetchOptions: {
+						...u,
+						signal: r
+					}
+				}
+			});
+		} catch (t) {
+			let n = o(t);
+			if (n) return e(n);
+			throw t;
+		}
+		let f = d.error;
+		if (f != null) {
+			let t = o(f);
+			if (t) return e(t);
+			throw f instanceof Error ? f : /* @__PURE__ */ Error("GraphQL query failed");
+		}
+		return d.data;
+	};
+}
+//#endregion
+export { n as apolloQueryExecutor };

package/dist/graphql/executors/apolloQueryExecutor.types.d.ts

@@ -0,0 +1,7 @@
+import { ApolloClient } from '@apollo/client';
+import { OxFormDataErrors } from '../../internal/hooks';
+export type ApolloQueryExecutorOptions<TForm extends object, TResult = unknown> = Omit<ApolloClient.QueryOptions<TResult>, 'query' | 'variables'> & {
+    client: ApolloClient;
+    extractErrors?: (error: unknown) => OxFormDataErrors<TForm> | null;
+    variables?: (payload: TForm) => Record<string, unknown>;
+};

package/dist/graphql/executors/graphqlErrors.d.ts

@@ -0,0 +1,2 @@
+import { OxFormDataErrors } from '../../internal/hooks';
+export declare function defaultExtractErrors<TForm extends object>(error: unknown): OxFormDataErrors<TForm> | null;

package/dist/graphql/executors/graphqlErrors.js

@@ -0,0 +1,19 @@
+//#region src/graphql/executors/graphqlErrors.ts
+function e(e) {
+	if (typeof e != "object" || !e) return [];
+	let t = e, n = t.errors ?? t.graphQLErrors ?? e;
+	return Array.isArray(n) ? n : [];
+}
+function t(e) {
+	return e.startsWith("input.") ? e.slice(6) : e;
+}
+function n(n) {
+	let r = e(n), i = {};
+	for (let e of r) {
+		let n = e.extensions?.validation;
+		if (n && typeof n == "object") for (let [e, r] of Object.entries(n)) i[t(e)] = String(Array.isArray(r) ? r[0] : r);
+	}
+	return Object.keys(i).length > 0 ? i : null;
+}
+//#endregion
+export { n as defaultExtractErrors };

package/dist/graphql/index.d.ts

@@ -0,0 +1,4 @@
+export { apolloMutationExecutor } from './executors/apolloMutationExecutor';
+export type { ApolloMutationExecutorOptions } from './executors/apolloMutationExecutor.types';
+export { apolloQueryExecutor } from './executors/apolloQueryExecutor';
+export type { ApolloQueryExecutorOptions } from './executors/apolloQueryExecutor.types';

package/dist/graphql.js

@@ -0,0 +1,3 @@
+import { apolloMutationExecutor as e } from "./graphql/executors/apolloMutationExecutor.js";
+import { apolloQueryExecutor as t } from "./graphql/executors/apolloQueryExecutor.js";
+export { e as apolloMutationExecutor, t as apolloQueryExecutor };

package/dist/hooks/index.d.ts

@@ -1,15 +1,10 @@
-export * from './useControllableState';
+export * from './useBreakpoint';
+export * from './useCommandShortcut';
 export * from './useDebounce';
-export * from './useFileUpload';
-export * from './useFilterFetch';
-export * from './useFilterQuery';
-export * from './useFocus';
+export * from './useFilter';
 export * from './useForm';
-export * from './useFormFetch';
-export * from './useFormState';
-export * from './useKeyboard';
-export * from './useOverflowDetection';
-export * from './useScrollSpy';
-export * from './useSize';
-export * from './useSort';
-export * from './useTheme';
+export * from './useMediaQuery';
+export * from './usePagination';
+export * from './usePoll';
+export * from './useRemember';
+export * from './useVirtualizer';

package/dist/hooks/useBreakpoint/index.d.ts

@@ -0,0 +1,2 @@
+export { oxBreakpoints, useOxBreakpoint, useOxBreakpointDown, useOxBreakpointUp, } from './useBreakpoint';
+export type { OxBreakpoint, OxBreakpointBucket } from './useBreakpoint.types';

package/dist/hooks/useBreakpoint/useBreakpoint.d.ts

@@ -0,0 +1,12 @@
+import { OxBreakpoint, OxBreakpointBucket } from './useBreakpoint.types';
+declare const oxBreakpoints: {
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly '2xl': 1536;
+};
+declare function useOxBreakpointUp(breakpoint: OxBreakpoint): boolean;
+declare function useOxBreakpointDown(breakpoint: OxBreakpoint): boolean;
+declare function useOxBreakpoint(): OxBreakpointBucket;
+export { oxBreakpoints, useOxBreakpoint, useOxBreakpointDown, useOxBreakpointUp };

package/dist/hooks/useBreakpoint/useBreakpoint.js

@@ -0,0 +1,32 @@
+import { require_compiler_runtime as e } from "../../node_modules/react/compiler-runtime.js";
+import { useOxMediaQuery as t } from "../useMediaQuery/useMediaQuery.js";
+//#region src/hooks/useBreakpoint/useBreakpoint.ts
+var n = e(), r = {
+	sm: 640,
+	md: 768,
+	lg: 1024,
+	xl: 1280,
+	"2xl": 1536
+}, i = (e) => `(min-width: ${r[e]}px)`, a = (e) => `(max-width: ${r[e] - .02}px)`;
+function o(e) {
+	let r = (0, n.c)(2), a;
+	return r[0] === e ? a = r[1] : (a = i(e), r[0] = e, r[1] = a), t(a);
+}
+function s(e) {
+	let r = (0, n.c)(2), i;
+	return r[0] === e ? i = r[1] : (i = a(e), r[0] = e, r[1] = i), t(i);
+}
+function c() {
+	let e = (0, n.c)(5), r;
+	e[0] === Symbol.for("react.memo_cache_sentinel") ? (r = i("sm"), e[0] = r) : r = e[0];
+	let a = t(r), o;
+	e[1] === Symbol.for("react.memo_cache_sentinel") ? (o = i("md"), e[1] = o) : o = e[1];
+	let s = t(o), c;
+	e[2] === Symbol.for("react.memo_cache_sentinel") ? (c = i("lg"), e[2] = c) : c = e[2];
+	let l = t(c), u;
+	e[3] === Symbol.for("react.memo_cache_sentinel") ? (u = i("xl"), e[3] = u) : u = e[3];
+	let d = t(u), f;
+	return e[4] === Symbol.for("react.memo_cache_sentinel") ? (f = i("2xl"), e[4] = f) : f = e[4], t(f) ? "2xl" : d ? "xl" : l ? "lg" : s ? "md" : a ? "sm" : "xs";
+}
+//#endregion
+export { r as oxBreakpoints, c as useOxBreakpoint, s as useOxBreakpointDown, o as useOxBreakpointUp };

package/dist/hooks/useBreakpoint/useBreakpoint.types.d.ts

@@ -0,0 +1,2 @@
+export type OxBreakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+export type OxBreakpointBucket = 'xs' | OxBreakpoint;

package/dist/hooks/useCommandShortcut/index.d.ts

@@ -0,0 +1,2 @@
+export { useOxCommandShortcut } from './useCommandShortcut';
+export type { UseOxCommandShortcutOptions } from './useCommandShortcut.types';

package/dist/hooks/useCommandShortcut/useCommandShortcut.d.ts

@@ -0,0 +1,3 @@
+import { UseOxCommandShortcutOptions } from './useCommandShortcut.types';
+declare function useOxCommandShortcut(handler: () => void, options?: UseOxCommandShortcutOptions): void;
+export { useOxCommandShortcut };

package/dist/hooks/useCommandShortcut/useCommandShortcut.js

@@ -0,0 +1,37 @@
+import { require_compiler_runtime as e } from "../../node_modules/react/compiler-runtime.js";
+import { useEffect as t, useEffectEvent as n } from "react";
+//#region src/hooks/useCommandShortcut/useCommandShortcut.ts
+var r = e();
+function i(e) {
+	if (!(e instanceof HTMLElement)) return !1;
+	if (e.isContentEditable) return !0;
+	let t = e.contentEditable;
+	if (t === "true" || t === "plaintext-only") return !0;
+	let n = e.tagName;
+	return [
+		"INPUT",
+		"TEXTAREA",
+		"SELECT"
+	].includes(n);
+}
+function a(e, a) {
+	let o = (0, r.c)(13), s;
+	o[0] === a ? s = o[1] : (s = a === void 0 ? {} : a, o[0] = a, o[1] = s);
+	let { enabled: c, ignoreWhileTyping: l, key: u, mod: d } = s, f = c === void 0 ? !0 : c, p = l === void 0 ? !0 : l, m = u === void 0 ? "k" : u, h = d === void 0 ? !0 : d, g = n(e), _;
+	o[2] !== f || o[3] !== p || o[4] !== m || o[5] !== h || o[6] !== g ? (_ = () => {
+		if (!f) return;
+		let e = (e) => {
+			!(!h || e.metaKey || e.ctrlKey) || e.key.toLowerCase() !== m.toLowerCase() || p && i(e.target) || (e.preventDefault(), g());
+		};
+		return document.addEventListener("keydown", e), () => document.removeEventListener("keydown", e);
+	}, o[2] = f, o[3] = p, o[4] = m, o[5] = h, o[6] = g, o[7] = _) : _ = o[7];
+	let v;
+	o[8] !== f || o[9] !== p || o[10] !== m || o[11] !== h ? (v = [
+		f,
+		p,
+		m,
+		h
+	], o[8] = f, o[9] = p, o[10] = m, o[11] = h, o[12] = v) : v = o[12], t(_, v);
+}
+//#endregion
+export { a as useOxCommandShortcut };

package/dist/hooks/useCommandShortcut/useCommandShortcut.types.d.ts

@@ -0,0 +1,6 @@
+export interface UseOxCommandShortcutOptions {
+    enabled?: boolean;
+    ignoreWhileTyping?: boolean;
+    key?: string;
+    mod?: boolean;
+}

package/dist/hooks/useDebounce/index.d.ts

@@ -1 +1,2 @@
-export * from './src/useDebounce';
+export { useOxDebounce, useOxDebouncedValue } from './useDebounce';
+export type { OxDebouncedCallback, OxDebouncedValue, OxDebouncedValueControls, UseOxDebouncedValueOptions, UseOxDebounceOptions, } from './useDebounce.types';

package/dist/hooks/useDebounce/useDebounce.d.ts

@@ -0,0 +1,4 @@
+import { OxDebouncedCallback, OxDebouncedValue, UseOxDebouncedValueOptions, UseOxDebounceOptions } from './useDebounce.types';
+declare function useOxDebounce<Arguments extends unknown[]>(callback: (...args: Arguments) => void, delay: number, options?: UseOxDebounceOptions): OxDebouncedCallback<Arguments>;
+declare function useOxDebouncedValue<T>(value: T, delay: number, options?: UseOxDebouncedValueOptions<T>): OxDebouncedValue<T>;
+export { useOxDebounce, useOxDebouncedValue };

package/dist/hooks/useDebounce/useDebounce.js

@@ -0,0 +1,82 @@
+import { require_compiler_runtime as e } from "../../node_modules/react/compiler-runtime.js";
+import { debounce as t } from "../../node_modules/es-toolkit/dist/function/debounce.js";
+import { useEffect as n, useRef as r, useState as i } from "react";
+//#region src/hooks/useDebounce/useDebounce.ts
+var a = e(), o = (e, t) => {
+	if (e && t) return ["leading", "trailing"];
+	if (e) return ["leading"];
+};
+function s(e, a, s = {}) {
+	let { leading: c = !1, trailing: l = !0 } = s, u = r(e), d = r(l), f = r(!1), p = r(null);
+	n(() => {
+		u.current = e, d.current = l;
+	}), n(() => {}, [a]);
+	let m = !c && !l;
+	n(() => {}, [m]), n(() => {
+		if (m) {
+			p.current = null;
+			return;
+		}
+		let e = Number.isNaN(a) || a < 0 ? 0 : a, n = o(c, l), r = t((...e) => {
+			f.current = !1, u.current(...e);
+		}, e, n ? { edges: n } : {});
+		return p.current = r, () => {
+			r.cancel(), f.current = !1, p.current = null;
+		};
+	}, [
+		a,
+		m,
+		c,
+		l
+	]);
+	let [h] = i(() => Object.assign((...e) => {
+		let t = p.current;
+		t !== null && (d.current && (f.current = !0), t(...e));
+	}, {
+		cancel: () => {
+			p.current?.cancel(), f.current = !1;
+		},
+		flush: () => {
+			p.current?.flush(), f.current = !1;
+		},
+		isPending: () => f.current
+	}));
+	return h;
+}
+function c(e, t, o) {
+	let c = (0, a.c)(23), l;
+	c[0] === o ? l = c[1] : (l = o === void 0 ? {} : o, c[0] = o, c[1] = l);
+	let { equalityFn: u, leading: d, trailing: f } = l, p = u === void 0 ? Object.is : u, [m, h] = i(e), [g, _] = i(!1), v = r(p), y = r(m), b;
+	c[2] !== m || c[3] !== p ? (b = () => {
+		v.current = p, y.current = m;
+	}, c[2] = m, c[3] = p, c[4] = b) : b = c[4], n(b);
+	let x;
+	c[5] === Symbol.for("react.memo_cache_sentinel") ? (x = (e) => {
+		h(e), _(!1);
+	}, c[5] = x) : x = c[5];
+	let S;
+	c[6] !== d || c[7] !== f ? (S = {
+		leading: d,
+		trailing: f
+	}, c[6] = d, c[7] = f, c[8] = S) : S = c[8];
+	let C = s(x, t, S), w, T;
+	c[9] !== C || c[10] !== e ? (w = () => {
+		v.current(e, y.current) || (_(!0), C(e));
+	}, T = [C, e], c[9] = C, c[10] = e, c[11] = w, c[12] = T) : (w = c[11], T = c[12]), n(w, T);
+	let E, D;
+	c[13] === C ? (E = c[14], D = c[15]) : (E = () => {
+		C.cancel(), _(!1);
+	}, D = () => {
+		C.flush();
+	}, c[13] = C, c[14] = E, c[15] = D);
+	let O;
+	c[16] !== g || c[17] !== E || c[18] !== D ? (O = {
+		cancel: E,
+		flush: D,
+		isPending: g
+	}, c[16] = g, c[17] = E, c[18] = D, c[19] = O) : O = c[19];
+	let k = O, A;
+	return c[20] !== k || c[21] !== m ? (A = [m, k], c[20] = k, c[21] = m, c[22] = A) : A = c[22], A;
+}
+//#endregion
+export { s as useOxDebounce, c as useOxDebouncedValue };

package/dist/hooks/useDebounce/useDebounce.types.d.ts

@@ -0,0 +1,19 @@
+export interface UseOxDebounceOptions {
+    leading?: boolean;
+    trailing?: boolean;
+}
+export interface OxDebouncedCallback<Arguments extends unknown[]> {
+    (...args: Arguments): void;
+    cancel: () => void;
+    flush: () => void;
+    isPending: () => boolean;
+}
+export interface UseOxDebouncedValueOptions<T> extends UseOxDebounceOptions {
+    equalityFn?: (a: T, b: T) => boolean;
+}
+export interface OxDebouncedValueControls {
+    cancel: () => void;
+    flush: () => void;
+    isPending: boolean;
+}
+export type OxDebouncedValue<T> = readonly [T, OxDebouncedValueControls];

package/dist/hooks/useFilter/index.d.ts

@@ -0,0 +1,2 @@
+export { useOxFilter } from './useFilter';
+export type { OxFilterParameters, OxFilterPayload, UseOxFilterOptions, UseOxFilterReturn, } from './useFilter.types';

package/dist/hooks/useFilter/useFilter.d.ts

@@ -0,0 +1,4 @@
+import { UseOxFilterOptions, UseOxFilterReturn } from './useFilter.types';
+declare const DEFAULT_DELAY_MS = 300;
+declare function useOxFilter<TFilter extends object, TResult = unknown, TSort = string>(options: UseOxFilterOptions<TFilter, TResult, TSort>): UseOxFilterReturn<TFilter, TResult, TSort>;
+export { DEFAULT_DELAY_MS, useOxFilter };

package/dist/hooks/useFilter/useFilter.js

@@ -0,0 +1,92 @@
+import { useFormState as e } from "../../internal/hooks/useFormState/useFormState.js";
+import { useOxDebounce as t } from "../useDebounce/useDebounce.js";
+import { OxFormErrors as n } from "../useForm/useForm.js";
+import { useEffect as r, useRef as i, useState as a } from "react";
+function o(o) {
+	let { delay: s = 300, executor: c, filter: l, immediate: u = !0, method: d = "get", onError: f, onSuccess: p, page: m = 1, pageSize: h, resetPageOnFilterChange: g = !0, sort: _, url: v } = o, { dataRef: y, form: b, isMounted: x } = e({ data: l }), [S, C] = a(m), [w, T] = a(h), [E, D] = a(_), [O, k] = a(void 0), [A, j] = a(void 0), [M, N] = a(!1), [P, F] = a(!1), I = i(S), L = i(w), R = i(E), z = i(c), B = i(p), V = i(f), H = i(d), U = i(v), W = i(null), G = i(0), K = i(!1), q = i(void 0);
+	r(() => {
+		I.current = S, L.current = w, R.current = E, z.current = c, B.current = p, V.current = f, H.current = d, U.current = v;
+	});
+	let J = async () => {
+		W.current?.abort();
+		let e = new AbortController();
+		W.current = e, G.current += 1;
+		let t = G.current;
+		N(!1), F(!0), j(void 0);
+		let r = {
+			...y.current,
+			page: I.current,
+			...L.current !== void 0 && { pageSize: L.current },
+			...R.current !== void 0 && { sort: R.current }
+		};
+		try {
+			let i = await z.current({
+				method: H.current,
+				payload: r,
+				signal: e.signal,
+				url: U.current
+			});
+			if (t !== G.current || !x.current) return;
+			if (i instanceof n) {
+				j(i.errors), V.current?.(i.errors);
+				return;
+			}
+			k(i), B.current?.(i);
+		} catch (n) {
+			if (e.signal.aborted || t !== G.current || !x.current) return;
+			j(n), V.current?.(n);
+		} finally {
+			t === G.current && x.current && F(!1), W.current === e && (W.current = null);
+		}
+	};
+	r(() => {
+		q.current = () => {
+			J();
+		};
+	});
+	let Y = t(() => {
+		J();
+	}, s), X = () => {
+		Y.cancel(), N(!1), J();
+	}, Z = () => {
+		g && I.current !== m && (I.current = m, C(m));
+	};
+	return r(() => {
+		K.current || (K.current = !0, u && q.current?.());
+	}, [u]), r(() => () => {
+		W.current?.abort();
+	}, []), {
+		cancel: () => {
+			Y.cancel(), N(!1), F(!1), G.current += 1, W.current?.abort();
+		},
+		data: O,
+		error: A,
+		filter: b.data,
+		isDirty: b.isDirty,
+		page: S,
+		pageSize: w,
+		pending: M,
+		processing: P,
+		refetch: () => {
+			X();
+		},
+		resetFilter: ((...e) => {
+			b.reset(...e), Z(), X();
+		}),
+		setFilter: ((...e) => {
+			b.setData(...e), Z(), N(!0), Y();
+		}),
+		setPage: (e) => {
+			I.current = e, C(e), X();
+		},
+		setPageSize: (e) => {
+			L.current = e, T(e), Z(), X();
+		},
+		setSort: (e) => {
+			R.current = e, D(e), Z(), X();
+		},
+		sort: E
+	};
+}
+//#endregion
+export { o as useOxFilter };

package/dist/hooks/useFilter/useFilter.types.d.ts

@@ -0,0 +1,40 @@
+import { ExecutorMethod, OxExecutor } from '../useForm';
+import { OxFormState } from '../../internal/hooks';
+export interface OxFilterParameters<TSort = string> {
+    page: number;
+    pageSize?: number;
+    sort?: TSort;
+}
+export type OxFilterPayload<TFilter extends object, TSort = string> = OxFilterParameters<TSort> & TFilter;
+export interface UseOxFilterOptions<TFilter extends object, TResult = unknown, TSort = string> {
+    delay?: number;
+    executor: OxExecutor<OxFilterPayload<TFilter, TSort>, TResult>;
+    filter: (() => TFilter) | TFilter;
+    immediate?: boolean;
+    method?: ExecutorMethod;
+    onError?: (error: unknown) => void;
+    onSuccess?: (result: TResult) => void;
+    page?: number;
+    pageSize?: number;
+    resetPageOnFilterChange?: boolean;
+    sort?: TSort;
+    url?: string;
+}
+export interface UseOxFilterReturn<TFilter extends object, TResult = unknown, TSort = string> {
+    cancel: () => void;
+    data: TResult | undefined;
+    error: unknown;
+    filter: TFilter;
+    isDirty: boolean;
+    page: number;
+    pageSize: number | undefined;
+    pending: boolean;
+    processing: boolean;
+    refetch: () => void;
+    resetFilter: OxFormState<TFilter>['reset'];
+    setFilter: OxFormState<TFilter>['setData'];
+    setPage: (page: number) => void;
+    setPageSize: (pageSize: number) => void;
+    setSort: (sort: TSort) => void;
+    sort: TSort | undefined;
+}

package/dist/hooks/useForm/index.d.ts

@@ -1,2 +1,4 @@
-export type * from './src/useForm.types';
-export { useForm } from './src/useForm';
+export type { OxProgress, OxResolver } from '../../internal/hooks';
+export { formErrors, OxFormErrors, useOxForm } from './useForm';
+export { standardSchemaResolver } from './standardSchemaResolver';
+export type { ExecutorContext, ExecutorMethod, OxExecutor, OxFormLifecycle, UseOxFormOptions, UseOxFormReturn, } from './useForm.types';

package/dist/hooks/useForm/standardSchemaResolver.d.ts

@@ -0,0 +1,22 @@
+import { OxResolver } from '../../internal/hooks';
+interface StandardSchemaV1<Output = unknown> {
+    readonly '~standard': {
+        readonly validate: (value: unknown) => StandardResult<Output> | Promise<StandardResult<Output>>;
+        readonly vendor: string;
+        readonly version: 1;
+    };
+}
+type StandardResult<Output> = {
+    readonly issues?: undefined;
+    readonly value: Output;
+} | {
+    readonly issues: readonly StandardIssue[];
+};
+interface StandardIssue {
+    readonly message: string;
+    readonly path?: readonly (PropertyKey | {
+        readonly key: PropertyKey;
+    })[];
+}
+export declare function standardSchemaResolver<TForm extends object>(schema: StandardSchemaV1<TForm>): OxResolver<TForm>;
+export {};

package/dist/hooks/useForm/standardSchemaResolver.js

@@ -0,0 +1,25 @@
+//#region src/hooks/useForm/standardSchemaResolver.ts
+var e = (e) => typeof e == "object" ? e.key : e;
+function t(t) {
+	return async (n) => {
+		let r = await t["~standard"].validate(n);
+		if (r.issues === void 0) return {
+			errors: {},
+			values: r.value
+		};
+		let i = {};
+		for (let t of r.issues) {
+			let n = (t.path ?? []).map((t) => e(t)).join(".");
+			Object.hasOwn(i, n) || (i[n] = {
+				message: t.message,
+				type: "validation"
+			});
+		}
+		return {
+			errors: i,
+			values: {}
+		};
+	};
+}
+//#endregion
+export { t as standardSchemaResolver };

package/dist/hooks/useForm/useForm.d.ts

@@ -0,0 +1,8 @@
+import { OxFormDataErrors } from '../../internal/hooks';
+import { UseOxFormOptions, UseOxFormReturn } from './useForm.types';
+export declare class OxFormErrors<TForm extends object> {
+    readonly errors: OxFormDataErrors<TForm>;
+    constructor(errors: OxFormDataErrors<TForm>);
+}
+export declare const formErrors: <TForm extends object>(errors: OxFormDataErrors<TForm>) => OxFormErrors<TForm>;
+export declare const useOxForm: <TForm extends object, TResult = unknown>({ data, executor, resolver, }: UseOxFormOptions<TForm, TResult>) => UseOxFormReturn<TForm, TResult>;

package/dist/hooks/useForm/useForm.js

@@ -0,0 +1,62 @@
+import { cloneDeep as e } from "../../node_modules/es-toolkit/dist/object/cloneDeep.js";
+import { useFormState as t } from "../../internal/hooks/useFormState/useFormState.js";
+import { useRef as n } from "react";
+//#region src/hooks/useForm/useForm.ts
+var r = class {
+	errors;
+	constructor(e) {
+		this.errors = e;
+	}
+}, i = (e) => new r(e), a = (e, t, n) => {
+	e ? n.onCancel?.() : n.onError?.(t);
+}, o = ({ data: i, executor: o, resolver: s }) => {
+	let { dataRef: c, defaultsCalledInOnSuccessRef: l, finishProcessing: u, form: d, isMounted: f, markAsSuccessful: p, resetBeforeSubmit: m, setDefaultsState: h, setProcessing: g, setProgress: _, transformRef: v } = t({
+		data: i,
+		resolver: s
+	}), y = n(null), b = async (t = {}, n, i) => {
+		if (m(), t.onBefore?.() === !1) return;
+		let b = new AbortController();
+		y.current = b;
+		try {
+			if (t.onCancelToken?.(b), g(!0), t.onStart?.(), s) {
+				let e = await d.validate();
+				if (e !== null) {
+					t.onError?.(e);
+					return;
+				}
+			}
+			let a = await o({
+				method: n,
+				onProgress: (e) => {
+					_(e), t.onProgress?.(e);
+				},
+				payload: v.current(c.current),
+				signal: b.signal,
+				url: i
+			});
+			if (a instanceof r) {
+				f.current && (d.clearErrors(), d.setError(a.errors)), t.onError?.(a.errors);
+				return;
+			}
+			f.current && p(), await t.onSuccess?.(a), f.current && !l.current && h(e(c.current));
+		} catch (e) {
+			a(b.signal.aborted, e, t);
+		} finally {
+			f.current && u(), y.current === b && (y.current = null), t.onFinish?.();
+		}
+	}, x = () => {
+		y.current?.abort();
+	}, S = (e) => (t, n) => b(n, e, t);
+	return {
+		...d,
+		cancel: x,
+		delete: S("delete"),
+		get: S("get"),
+		patch: S("patch"),
+		post: S("post"),
+		put: S("put"),
+		submit: (e) => b(e)
+	};
+};
+//#endregion
+export { r as OxFormErrors, i as formErrors, o as useOxForm };