@questpie/admin 2.0.0 → 3.0.1

package/dist/client/hooks/use-reactive-fields.d.mts

@@ -1,3 +1,4 @@
+import { UseFormReturn } from "react-hook-form";
 import { FieldReactiveSchema } from "questpie/client";
 
 //#region src/client/hooks/use-reactive-fields.d.ts
@@ -33,6 +34,8 @@ interface UseReactiveFieldsOptions {
   debounce?: number;
   /** Whether to enable reactive updates */
   enabled?: boolean;
+  /** Form instance - pass directly when calling outside FormProvider */
+  form?: UseFormReturn<any>;
 }
 /**
  * Result from useReactiveFields hook
@@ -68,8 +71,8 @@ declare function useReactiveFields({
   mode,
   reactiveConfigs,
   debounce,
-  enabled
+  enabled,
+  form: formProp
 }: UseReactiveFieldsOptions): UseReactiveFieldsResult;
 //#endregion
-export { ReactiveFieldResult, ReactiveFieldState, UseReactiveFieldsOptions, UseReactiveFieldsResult, useReactiveFields };
-//# sourceMappingURL=use-reactive-fields.d.mts.map
+export { ReactiveFieldResult, ReactiveFieldState, UseReactiveFieldsOptions, UseReactiveFieldsResult, useReactiveFields };

package/dist/client/hooks/use-reactive-fields.mjs

@@ -1,9 +1,16 @@
 import { useAdminStore } from "../runtime/provider.mjs";
-import * as React$1 from "react";
+import * as React from "react";
+import { useMutation } from "@tanstack/react-query";
 import { useFormContext, useWatch } from "react-hook-form";
 
 //#region src/client/hooks/use-reactive-fields.ts
 /**
+* Reactive Fields Hook
+*
+* Watches form changes and triggers server-side reactive handlers.
+* Supports batched RPC calls with debouncing.
+*/
+/**
 * Get sibling data for a field path (for fields inside arrays)
 */
 function getSiblingData(values, fieldPath) {
@@ -16,23 +23,48 @@ function getSiblingData(values, fieldPath) {
 	else return null;
 	return typeof sibling === "object" ? sibling : null;
 }
-/**
-* Build watch dependencies from reactive configs
-*/
-function buildWatchDependencies(reactiveConfigs) {
-	const deps = /* @__PURE__ */ new Set();
-	for (const config of Object.values(reactiveConfigs)) for (const key of [
+function normalizeWatchDeps(deps) {
+	if (!deps?.length) return [];
+	return deps.filter((dep) => dep.length > 0 && !dep.startsWith("$"));
+}
+function buildReactiveRequestDescriptors(reactiveConfigs) {
+	const descriptors = [];
+	for (const [field, config] of Object.entries(reactiveConfigs)) for (const type of [
 		"hidden",
 		"readOnly",
 		"disabled",
 		"compute"
 	]) {
-		const reactiveConfig = config[key];
-		if (reactiveConfig?.watch) {
-			for (const dep of reactiveConfig.watch) if (!dep.startsWith("$")) deps.add(dep);
-		}
+		const reactiveConfig = config[type];
+		if (!reactiveConfig) continue;
+		descriptors.push({
+			field,
+			type,
+			watchDeps: normalizeWatchDeps(reactiveConfig.watch)
+		});
 	}
-	return deps;
+	return descriptors;
+}
+function buildDependencyGraph(descriptors) {
+	const graph = /* @__PURE__ */ new Map();
+	for (const descriptor of descriptors) for (const dep of descriptor.watchDeps) {
+		const items = graph.get(dep) ?? [];
+		items.push(descriptor);
+		graph.set(dep, items);
+	}
+	return graph;
+}
+function mapDepValues(deps, watchedValues) {
+	if (deps.length === 0) return {};
+	const values = Array.isArray(watchedValues) ? watchedValues : [watchedValues];
+	const result = {};
+	for (const [index, dep] of deps.entries()) result[dep] = values[index];
+	return result;
+}
+function getChangedDeps(prevDeps, nextDeps) {
+	const changed = [];
+	for (const [dep, value] of Object.entries(nextDeps)) if (prevDeps[dep] !== value) changed.push(dep);
+	return changed;
 }
 /**
 * Hook to manage reactive field states.
@@ -50,115 +82,120 @@ function buildWatchDependencies(reactiveConfigs) {
 * const isReadOnly = fieldStates["slug"]?.readOnly ?? false;
 * ```
 */
-function useReactiveFields({ collection, mode = "collection", reactiveConfigs, debounce = 100, enabled = true }) {
+function useReactiveFields({ collection, mode = "collection", reactiveConfigs, debounce = 100, enabled = true, form: formProp }) {
 	const client = useAdminStore((s) => s.client);
-	const form = useFormContext();
-	const [fieldStates, setFieldStates] = React$1.useState({});
-	const [isPending, setIsPending] = React$1.useState(false);
-	const [error, setError] = React$1.useState(null);
-	const watchDeps = React$1.useMemo(() => buildWatchDependencies(reactiveConfigs), [reactiveConfigs]);
-	const watchedValues = useWatch({ control: form.control });
-	const formValues = React$1.useMemo(() => watchedValues ?? {}, [watchedValues]);
-	const prevValuesRef = React$1.useRef({});
-	const debounceTimerRef = React$1.useRef(null);
-	const fetchReactiveStates = React$1.useCallback(async () => {
-		if (!enabled || !client || Object.keys(reactiveConfigs).length === 0) return;
-		const requests = [];
-		for (const [fieldPath, config] of Object.entries(reactiveConfigs)) {
-			const siblingData = getSiblingData(formValues, fieldPath);
-			const prevSiblingData = getSiblingData(prevValuesRef.current, fieldPath);
-			for (const type of [
-				"hidden",
-				"readOnly",
-				"disabled",
-				"compute"
-			]) if (config[type]?.watch) requests.push({
-				field: fieldPath,
-				type,
-				formData: formValues,
-				siblingData,
-				prevData: prevValuesRef.current,
-				prevSiblingData
-			});
-		}
-		if (requests.length === 0) return;
-		setIsPending(true);
-		setError(null);
-		try {
-			const response = await client.rpc.batchReactive({
+	const formContext = useFormContext();
+	const form = formProp ?? formContext;
+	const [fieldStates, setFieldStates] = React.useState({});
+	const requestDescriptors = React.useMemo(() => buildReactiveRequestDescriptors(reactiveConfigs), [reactiveConfigs]);
+	const dependencyGraph = React.useMemo(() => buildDependencyGraph(requestDescriptors), [requestDescriptors]);
+	const watchDeps = React.useMemo(() => [...new Set(requestDescriptors.flatMap((item) => item.watchDeps))], [requestDescriptors]);
+	const watchedDepValues = useWatch({
+		control: form?.control,
+		name: watchDeps,
+		disabled: !form || watchDeps.length === 0
+	});
+	const currentDepValues = React.useMemo(() => mapDepValues(watchDeps, watchedDepValues), [watchDeps, watchedDepValues]);
+	const prevFormValuesRef = React.useRef({});
+	const prevDepValuesRef = React.useRef({});
+	const isInitializedRef = React.useRef(false);
+	const debounceTimerRef = React.useRef(null);
+	const mutateRef = React.useRef(void 0);
+	const reactiveMutation = useMutation({
+		mutationFn: async (descriptors) => {
+			if (!client) return { results: [] };
+			const formData = form.getValues() ?? {};
+			const prevData = prevFormValuesRef.current;
+			const requests = descriptors.map((descriptor) => ({
+				field: descriptor.field,
+				type: descriptor.type,
+				siblingData: getSiblingData(formData, descriptor.field),
+				prevSiblingData: getSiblingData(prevData, descriptor.field)
+			}));
+			return client.routes.batchReactive({
 				collection,
 				type: mode,
+				formData,
+				prevData,
 				requests
 			});
-			const newStates = { ...fieldStates };
-			for (const result of response.results) {
-				if (!newStates[result.field]) newStates[result.field] = {};
-				if (result.type === "compute") {
-					if (result.value !== void 0) form.setValue(result.field, result.value, {
-						shouldDirty: true,
-						shouldTouch: false,
-						shouldValidate: false
-					});
-				} else newStates[result.field][result.type] = result.value;
-			}
-			setFieldStates(newStates);
-		} catch (err) {
-			console.error("Reactive fields error:", err);
-			setError(err instanceof Error ? err : new Error(String(err)));
-		} finally {
-			setIsPending(false);
+		},
+		onSuccess: (response) => {
+			setFieldStates((prevState) => {
+				const nextState = { ...prevState };
+				for (const result of response.results) {
+					if (!nextState[result.field]) nextState[result.field] = {};
+					if (result.type === "compute") {
+						if (result.value !== void 0) form.setValue(result.field, result.value, {
+							shouldDirty: true,
+							shouldTouch: false,
+							shouldValidate: true
+						});
+					} else nextState[result.field][result.type] = result.value;
+				}
+				return nextState;
+			});
+			prevFormValuesRef.current = { ...form.getValues() ?? {} };
 		}
+	});
+	mutateRef.current = reactiveMutation.mutate;
+	React.useEffect(() => {
+		isInitializedRef.current = false;
+		prevFormValuesRef.current = {};
+		prevDepValuesRef.current = {};
+		if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
 	}, [
-		enabled,
-		client,
 		collection,
 		mode,
-		reactiveConfigs,
-		formValues,
-		fieldStates,
-		form
+		requestDescriptors
 	]);
-	const isInitializedRef = React$1.useRef(false);
-	React$1.useEffect(() => {
-		if (!enabled || watchDeps.size === 0) return;
-		if (!Object.keys(formValues).some((key) => formValues[key] !== void 0 && formValues[key] !== null)) return;
+	React.useEffect(() => {
+		if (!enabled || requestDescriptors.length === 0) return;
 		if (!isInitializedRef.current) {
 			isInitializedRef.current = true;
-			prevValuesRef.current = { ...formValues };
-			fetchReactiveStates();
+			prevFormValuesRef.current = { ...form.getValues() ?? {} };
+			prevDepValuesRef.current = currentDepValues;
+			mutateRef.current?.(requestDescriptors);
 			return;
 		}
-		let hasChanges = false;
-		for (const dep of watchDeps) if (formValues[dep] !== prevValuesRef.current[dep]) {
-			hasChanges = true;
-			break;
+		if (watchDeps.length === 0) return;
+		const changedDeps = getChangedDeps(prevDepValuesRef.current, currentDepValues);
+		if (changedDeps.length === 0) return;
+		prevDepValuesRef.current = currentDepValues;
+		const affectedDescriptors = /* @__PURE__ */ new Map();
+		for (const dep of changedDeps) {
+			const depDescriptors = dependencyGraph.get(dep) ?? [];
+			for (const descriptor_0 of depDescriptors) affectedDescriptors.set(`${descriptor_0.field}:${descriptor_0.type}`, descriptor_0);
 		}
-		if (!hasChanges) return;
-		prevValuesRef.current = { ...formValues };
+		if (affectedDescriptors.size === 0) return;
 		if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
 		debounceTimerRef.current = setTimeout(() => {
-			fetchReactiveStates();
+			mutateRef.current?.([...affectedDescriptors.values()]);
 		}, debounce);
 		return () => {
 			if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
 		};
 	}, [
 		enabled,
+		requestDescriptors,
+		form,
+		currentDepValues,
 		watchDeps,
-		formValues,
-		debounce,
-		fetchReactiveStates
+		dependencyGraph,
+		debounce
 	]);
+	React.useEffect(() => {
+		return () => {
+			if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+		};
+	}, []);
 	return {
 		fieldStates,
-		isPending,
-		error,
-		refresh: React$1.useCallback(() => {
-			fetchReactiveStates();
-		}, [fetchReactiveStates])
+		isPending: reactiveMutation.isPending,
+		error: reactiveMutation.error ?? null,
+		refresh: () => mutateRef.current?.(requestDescriptors)
 	};
 }
 
 //#endregion
-export { useReactiveFields };
-//# sourceMappingURL=use-reactive-fields.mjs.map
+export { useReactiveFields };

package/dist/client/hooks/use-realtime-highlight.mjs

@@ -1,3 +1,4 @@
+import { c } from "react/compiler-runtime";
 import { useEffect, useRef, useState } from "react";
 
 //#region src/client/hooks/use-realtime-highlight.ts
@@ -21,66 +22,128 @@ import { useEffect, useRef, useState } from "react";
 * ))}
 * ```
 */
-function useRealtimeHighlight(docs, options = {}) {
-	const { highlightDuration = 1500, enabled = true, initializationGracePeriod = 500 } = options;
-	const [highlightedIds, setHighlightedIds] = useState(/* @__PURE__ */ new Set());
-	const prevDocsRef = useRef(/* @__PURE__ */ new Map());
+function useRealtimeHighlight(docs, t0) {
+	const $ = c(18);
+	let t1;
+	if ($[0] !== t0) {
+		t1 = t0 === void 0 ? {} : t0;
+		$[0] = t0;
+		$[1] = t1;
+	} else t1 = $[1];
+	const { highlightDuration: t2, enabled: t3, initializationGracePeriod: t4 } = t1;
+	const highlightDuration = t2 === void 0 ? 1500 : t2;
+	const enabled = t3 === void 0 ? true : t3;
+	const initializationGracePeriod = t4 === void 0 ? 500 : t4;
+	let t5;
+	if ($[2] === Symbol.for("react.memo_cache_sentinel")) {
+		t5 = /* @__PURE__ */ new Set();
+		$[2] = t5;
+	} else t5 = $[2];
+	const [highlightedIds, setHighlightedIds] = useState(t5);
+	let t6;
+	if ($[3] === Symbol.for("react.memo_cache_sentinel")) {
+		t6 = /* @__PURE__ */ new Map();
+		$[3] = t6;
+	} else t6 = $[3];
+	const prevDocsRef = useRef(t6);
 	const hasInitializedRef = useRef(false);
 	const initializedAtRef = useRef(0);
-	const timersRef = useRef(/* @__PURE__ */ new Set());
-	useEffect(() => {
-		return () => {
+	let t7;
+	if ($[4] === Symbol.for("react.memo_cache_sentinel")) {
+		t7 = /* @__PURE__ */ new Set();
+		$[4] = t7;
+	} else t7 = $[4];
+	const timersRef = useRef(t7);
+	let t8;
+	let t9;
+	if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+		t8 = () => () => {
 			for (const timer of timersRef.current) clearTimeout(timer);
 		};
-	}, []);
-	useEffect(() => {
-		if (!enabled || !docs) return;
-		const currentMap = /* @__PURE__ */ new Map();
-		for (const doc of docs) currentMap.set(doc.id, getDocFingerprint(doc));
-		if (!hasInitializedRef.current) {
-			hasInitializedRef.current = true;
-			initializedAtRef.current = Date.now();
+		t9 = [];
+		$[5] = t8;
+		$[6] = t9;
+	} else {
+		t8 = $[5];
+		t9 = $[6];
+	}
+	useEffect(t8, t9);
+	let t10;
+	let t11;
+	if ($[7] !== docs || $[8] !== enabled || $[9] !== highlightDuration || $[10] !== initializationGracePeriod) {
+		t10 = () => {
+			if (!enabled || !docs) return;
+			const currentMap = /* @__PURE__ */ new Map();
+			for (const doc of docs) currentMap.set(doc.id, getDocFingerprint(doc));
+			if (!hasInitializedRef.current) {
+				hasInitializedRef.current = true;
+				initializedAtRef.current = Date.now();
+				prevDocsRef.current = currentMap;
+				return;
+			}
+			if (Date.now() - initializedAtRef.current < initializationGracePeriod) {
+				prevDocsRef.current = currentMap;
+				return;
+			}
+			const changedIds = [];
+			for (const doc_0 of docs) {
+				const prevFingerprint = prevDocsRef.current.get(doc_0.id);
+				const currentFingerprint = currentMap.get(doc_0.id);
+				if (!prevFingerprint) changedIds.push(doc_0.id);
+				else if (prevFingerprint !== currentFingerprint) changedIds.push(doc_0.id);
+			}
 			prevDocsRef.current = currentMap;
-			return;
-		}
-		if (Date.now() - initializedAtRef.current < initializationGracePeriod) {
-			prevDocsRef.current = currentMap;
-			return;
-		}
-		const changedIds = [];
-		for (const doc of docs) {
-			const prevFingerprint = prevDocsRef.current.get(doc.id);
-			const currentFingerprint = currentMap.get(doc.id);
-			if (!prevFingerprint) changedIds.push(doc.id);
-			else if (prevFingerprint !== currentFingerprint) changedIds.push(doc.id);
-		}
-		prevDocsRef.current = currentMap;
-		if (changedIds.length > 0) {
-			setHighlightedIds((prev) => {
-				const next = new Set(prev);
-				for (const id of changedIds) next.add(id);
-				return next;
-			});
-			const timer = setTimeout(() => {
+			if (changedIds.length > 0) {
 				setHighlightedIds((prev) => {
 					const next = new Set(prev);
-					for (const id of changedIds) next.delete(id);
+					for (const id of changedIds) next.add(id);
 					return next;
 				});
-				timersRef.current.delete(timer);
-			}, highlightDuration);
-			timersRef.current.add(timer);
-		}
-	}, [
-		docs,
-		enabled,
-		highlightDuration,
-		initializationGracePeriod
-	]);
-	return {
-		highlightedIds,
-		isHighlighted: (id) => highlightedIds.has(id)
-	};
+				const timer_0 = setTimeout(() => {
+					setHighlightedIds((prev_0) => {
+						const next_0 = new Set(prev_0);
+						for (const id_0 of changedIds) next_0.delete(id_0);
+						return next_0;
+					});
+					timersRef.current.delete(timer_0);
+				}, highlightDuration);
+				timersRef.current.add(timer_0);
+			}
+		};
+		t11 = [
+			docs,
+			enabled,
+			highlightDuration,
+			initializationGracePeriod
+		];
+		$[7] = docs;
+		$[8] = enabled;
+		$[9] = highlightDuration;
+		$[10] = initializationGracePeriod;
+		$[11] = t10;
+		$[12] = t11;
+	} else {
+		t10 = $[11];
+		t11 = $[12];
+	}
+	useEffect(t10, t11);
+	let t12;
+	if ($[13] !== highlightedIds) {
+		t12 = (id_1) => highlightedIds.has(id_1);
+		$[13] = highlightedIds;
+		$[14] = t12;
+	} else t12 = $[14];
+	let t13;
+	if ($[15] !== highlightedIds || $[16] !== t12) {
+		t13 = {
+			highlightedIds,
+			isHighlighted: t12
+		};
+		$[15] = highlightedIds;
+		$[16] = t12;
+		$[17] = t13;
+	} else t13 = $[17];
+	return t13;
 }
 /**
 * Create a fingerprint for a doc to detect changes
@@ -92,5 +155,4 @@ function getDocFingerprint(doc) {
 }
 
 //#endregion
-export { useRealtimeHighlight };
-//# sourceMappingURL=use-realtime-highlight.mjs.map
+export { useRealtimeHighlight };

package/dist/client/hooks/use-saved-views.mjs

@@ -1,65 +1,140 @@
 import { useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 
 //#region src/client/hooks/use-saved-views.ts
 /**
 * Hook to fetch saved views for a collection
 *
-* Note: This hook requires the adminModule to be used in your CMS setup.
-* If adminSavedViews collection is not available, returns empty array.
+* Note: This hook requires the `adminModule` to be used in your app setup.
+* If admin_saved_views collection is not available, returns empty array.
 */
 function useSavedViews(collectionName) {
-	const client = useAdminStore((s) => s.client);
-	return useQuery({
-		queryKey: ["adminSavedViews", collectionName],
-		queryFn: async () => {
+	const $ = c(9);
+	const client = useAdminStore(_temp);
+	let t0;
+	if ($[0] !== collectionName) {
+		t0 = ["admin_saved_views", collectionName];
+		$[0] = collectionName;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== client?.collections || $[3] !== collectionName) {
+		t1 = async () => {
 			const collections = client?.collections;
-			if (!collections?.adminSavedViews) return { docs: [] };
-			return { docs: (await collections.adminSavedViews.find({ where: { collectionName } }))?.docs ?? [] };
-		},
-		enabled: !!client
-	});
+			if (!collections?.admin_saved_views) return { docs: [] };
+			return { docs: (await collections.admin_saved_views.find({ where: { collectionName } }))?.docs ?? [] };
+		};
+		$[2] = client?.collections;
+		$[3] = collectionName;
+		$[4] = t1;
+	} else t1 = $[4];
+	const t2 = !!client;
+	let t3;
+	if ($[5] !== t0 || $[6] !== t1 || $[7] !== t2) {
+		t3 = {
+			queryKey: t0,
+			queryFn: t1,
+			enabled: t2
+		};
+		$[5] = t0;
+		$[6] = t1;
+		$[7] = t2;
+		$[8] = t3;
+	} else t3 = $[8];
+	return useQuery(t3);
 }
 /**
 * Hook to save a new view
 */
+function _temp(s) {
+	return s.client;
+}
 function useSaveView(collectionName) {
-	const client = useAdminStore((s) => s.client);
+	const $ = c(9);
+	const client = useAdminStore(_temp2);
 	const queryClient = useQueryClient();
-	return useMutation({
-		mutationFn: async (data) => {
+	let t0;
+	if ($[0] !== client?.collections || $[1] !== collectionName) {
+		t0 = async (data) => {
 			const collections = client?.collections;
-			if (!collections?.adminSavedViews) throw new Error("adminSavedViews collection not available. Make sure to use adminModule in your CMS setup.");
-			return collections.adminSavedViews.create({
+			if (!collections?.admin_saved_views) throw new Error("admin_saved_views collection not available. Make sure to use the adminModule in your app setup.");
+			return collections.admin_saved_views.create({
 				...data,
 				collectionName,
 				userId: data.userId || "anonymous",
 				isDefault: false
 			});
-		},
-		onSuccess: () => {
-			queryClient.invalidateQueries({ queryKey: ["adminSavedViews", collectionName] });
-		}
-	});
+		};
+		$[0] = client?.collections;
+		$[1] = collectionName;
+		$[2] = t0;
+	} else t0 = $[2];
+	let t1;
+	if ($[3] !== collectionName || $[4] !== queryClient) {
+		t1 = () => {
+			queryClient.invalidateQueries({ queryKey: ["admin_saved_views", collectionName] });
+		};
+		$[3] = collectionName;
+		$[4] = queryClient;
+		$[5] = t1;
+	} else t1 = $[5];
+	let t2;
+	if ($[6] !== t0 || $[7] !== t1) {
+		t2 = {
+			mutationFn: t0,
+			onSuccess: t1
+		};
+		$[6] = t0;
+		$[7] = t1;
+		$[8] = t2;
+	} else t2 = $[8];
+	return useMutation(t2);
 }
 /**
-* Hook to delete a view
+* Hook to update an existing view
 */
+function _temp2(s) {
+	return s.client;
+}
 function useDeleteSavedView(collectionName) {
-	const client = useAdminStore((s) => s.client);
+	const $ = c(8);
+	const client = useAdminStore(_temp4);
 	const queryClient = useQueryClient();
-	return useMutation({
-		mutationFn: async (viewId) => {
+	let t0;
+	if ($[0] !== client?.collections) {
+		t0 = async (viewId) => {
 			const collections = client?.collections;
-			if (!collections?.adminSavedViews) throw new Error("adminSavedViews collection not available. Make sure to use adminModule in your CMS setup.");
-			return collections.adminSavedViews.delete({ id: viewId });
-		},
-		onSuccess: () => {
-			queryClient.invalidateQueries({ queryKey: ["adminSavedViews", collectionName] });
-		}
-	});
+			if (!collections?.admin_saved_views) throw new Error("admin_saved_views collection not available. Make sure to use the adminModule in your app setup.");
+			return collections.admin_saved_views.delete({ id: viewId });
+		};
+		$[0] = client?.collections;
+		$[1] = t0;
+	} else t0 = $[1];
+	let t1;
+	if ($[2] !== collectionName || $[3] !== queryClient) {
+		t1 = () => {
+			queryClient.invalidateQueries({ queryKey: ["admin_saved_views", collectionName] });
+		};
+		$[2] = collectionName;
+		$[3] = queryClient;
+		$[4] = t1;
+	} else t1 = $[4];
+	let t2;
+	if ($[5] !== t0 || $[6] !== t1) {
+		t2 = {
+			mutationFn: t0,
+			onSuccess: t1
+		};
+		$[5] = t0;
+		$[6] = t1;
+		$[7] = t2;
+	} else t2 = $[7];
+	return useMutation(t2);
+}
+function _temp4(s) {
+	return s.client;
 }
 
 //#endregion
-export { useDeleteSavedView, useSaveView, useSavedViews };
-//# sourceMappingURL=use-saved-views.mjs.map
+export { useDeleteSavedView, useSaveView, useSavedViews };