@questpie/admin 2.0.0 → 3.0.1

package/dist/client/hooks/use-transition-stage.mjs

@@ -0,0 +1,125 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { c } from "react/compiler-runtime";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-transition-stage.ts
+/**
+* Workflow Transition Hook
+*
+* Provides a mutation for transitioning collection/global records between
+* workflow stages. Supports optional scheduled transitions via `scheduledAt`.
+*
+* Uses direct fetch (same pattern as audit fetcher) because the generated
+* client SDK does not yet expose the `scheduledAt` parameter.
+*
+* @example
+* ```tsx
+* // Collection transition
+* const transition = useTransitionStage("posts");
+* await transition.mutateAsync({ id: "123", stage: "published" });
+*
+* // Scheduled transition
+* await transition.mutateAsync({
+*   id: "123",
+*   stage: "published",
+*   scheduledAt: new Date("2025-03-01T09:00:00Z"),
+* });
+*
+* // Global transition (no id needed)
+* const globalTransition = useTransitionStage("siteSettings", { mode: "global" });
+* await globalTransition.mutateAsync({ stage: "published" });
+* ```
+*/
+/**
+* Hook for transitioning a collection record or global between workflow stages.
+*
+* Invalidates relevant queries on success so the UI refreshes automatically
+* (collection/global data, versions, audit history).
+*
+* @param resourceName - Collection slug or global name
+* @param options - Optional configuration (mode, mutationOptions)
+*/
+function useTransitionStage(resourceName, options) {
+	const $ = c(14);
+	const mode = options?.mode ?? "collection";
+	const client = useAdminStore(selectClient);
+	const queryClient = useQueryClient();
+	let t0;
+	if ($[0] !== client) {
+		t0 = client.getBasePath?.() ?? "";
+		$[0] = client;
+		$[1] = t0;
+	} else t0 = $[1];
+	const basePath = t0;
+	let t1;
+	if ($[2] !== basePath || $[3] !== mode || $[4] !== resourceName) {
+		t1 = async (params) => {
+			const body = { stage: params.stage };
+			if (params.scheduledAt) body.scheduledAt = params.scheduledAt instanceof Date ? params.scheduledAt.toISOString() : params.scheduledAt;
+			const url = mode === "global" ? `${basePath}/globals/${resourceName}/transition` : `${basePath}/${resourceName}/${params.id}/transition`;
+			const response = await fetch(url, {
+				method: "POST",
+				credentials: "include",
+				headers: {
+					"Content-Type": "application/json",
+					Accept: "application/json"
+				},
+				body: JSON.stringify(body)
+			});
+			if (!response.ok) {
+				const error = await response.json().catch(_temp);
+				throw new Error(error.message ?? error.error ?? "Transition failed");
+			}
+			return response.json();
+		};
+		$[2] = basePath;
+		$[3] = mode;
+		$[4] = resourceName;
+		$[5] = t1;
+	} else t1 = $[5];
+	let t2;
+	if ($[6] !== mode || $[7] !== queryClient || $[8] !== resourceName) {
+		t2 = () => {
+			if (mode === "collection") queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"collections",
+				resourceName
+			] });
+			else queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"globals",
+				resourceName
+			] });
+			queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"audit",
+				mode,
+				resourceName
+			] });
+		};
+		$[6] = mode;
+		$[7] = queryClient;
+		$[8] = resourceName;
+		$[9] = t2;
+	} else t2 = $[9];
+	const t3 = options?.mutationOptions;
+	let t4;
+	if ($[10] !== t1 || $[11] !== t2 || $[12] !== t3) {
+		t4 = {
+			mutationFn: t1,
+			onSuccess: t2,
+			...t3
+		};
+		$[10] = t1;
+		$[11] = t2;
+		$[12] = t3;
+		$[13] = t4;
+	} else t4 = $[13];
+	return useMutation(t4);
+}
+function _temp() {
+	return {};
+}
+
+//#endregion
+export { useTransitionStage };

package/dist/client/hooks/use-upload-collection.mjs

@@ -28,5 +28,4 @@ function useUploadCollection(preferred) {
 }
 
 //#endregion
-export { useUploadCollection };
-//# sourceMappingURL=use-upload-collection.mjs.map
+export { useUploadCollection };

package/dist/client/hooks/use-upload.mjs

@@ -1,145 +1,209 @@
 import { selectClient, useAdminStore } from "../runtime/provider.mjs";
 import { useUploadCollection } from "./use-upload-collection.mjs";
-import { useQueryClient } from "@tanstack/react-query";
-import { useCallback, useState } from "react";
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
 
 //#region src/client/hooks/use-upload.ts
-/**
-* useUpload Hook
-*
-* Handles file uploads to the CMS with progress tracking.
-* Uses the QuestpieClient's upload method which uses XMLHttpRequest for progress.
-*
-* @example
-* ```tsx
-* const { upload, uploadMany, isUploading, progress } = useUpload();
-*
-* // Single file upload
-* const asset = await upload(file);
-*
-* // Multiple files upload
-* const assets = await uploadMany(files, {
-*   onProgress: (p) => console.log(`${p}%`),
-* });
-* ```
-*/
-/**
-* Hook for uploading files to the CMS
-*
-* Uses the QuestpieClient's built-in upload method which provides
-* progress tracking via XMLHttpRequest.
-*/
+var UploadError = class extends Error {
+	constructor(message, status, response) {
+		super(message);
+		this.status = status;
+		this.response = response;
+		this.name = "UploadError";
+	}
+};
 function useUpload() {
+	const $ = c(36);
 	const client = useAdminStore(selectClient);
 	const queryClient = useQueryClient();
 	const { collection: defaultUploadCollection, collections: uploadCollections } = useUploadCollection();
-	const [isUploading, setIsUploading] = useState(false);
 	const [progress, setProgress] = useState(0);
-	const [error, setError] = useState(null);
-	const resolveTargetCollection = useCallback((to) => {
-		const explicit = typeof to === "string" ? to.trim() : "";
-		if (explicit.length > 0) return explicit;
-		return defaultUploadCollection;
-	}, [defaultUploadCollection]);
-	const getMissingCollectionMessage = useCallback(() => {
-		if (uploadCollections.length === 0) return "No upload-enabled collection is registered. Configure a collection with .upload() and ensure it is accessible in admin config.";
-		if (uploadCollections.length > 1) return `Multiple upload collections are available (${uploadCollections.join(", ")}). Pass UploadOptions.to to select one.`;
-		return "Upload collection is not configured.";
-	}, [uploadCollections]);
-	return {
-		upload: useCallback(async (file, options = {}) => {
-			const { to, onProgress, signal } = options;
-			const targetCollection = resolveTargetCollection(to);
-			if (!targetCollection) {
-				const missingCollectionError = new Error(getMissingCollectionMessage());
-				setError(missingCollectionError);
-				throw missingCollectionError;
-			}
-			setIsUploading(true);
+	let t0;
+	if ($[0] !== defaultUploadCollection) {
+		t0 = (to) => {
+			const explicit = typeof to === "string" ? to.trim() : "";
+			if (explicit.length > 0) return explicit;
+			return defaultUploadCollection;
+		};
+		$[0] = defaultUploadCollection;
+		$[1] = t0;
+	} else t0 = $[1];
+	const resolveTargetCollection = t0;
+	let t1;
+	if ($[2] !== uploadCollections) {
+		t1 = () => {
+			if (uploadCollections.length === 0) return "No upload-enabled collection is registered. Configure a collection with .upload() and ensure it is accessible in admin config.";
+			if (uploadCollections.length > 1) return `Multiple upload collections are available (${uploadCollections.join(", ")}). Pass UploadOptions.to to select one.`;
+			return "Upload collection is not configured.";
+		};
+		$[2] = uploadCollections;
+		$[3] = t1;
+	} else t1 = $[3];
+	const getMissingCollectionMessage = t1;
+	let t2;
+	if ($[4] !== client || $[5] !== getMissingCollectionMessage || $[6] !== resolveTargetCollection) {
+		t2 = async (t3$1) => {
+			const { file, options } = t3$1;
+			const { to: to_0, onProgress, signal } = options ?? {};
+			const targetCollection = resolveTargetCollection(to_0);
+			if (!targetCollection) throw new Error(getMissingCollectionMessage());
+			const collectionApi = client.collections[targetCollection];
+			if (!collectionApi?.upload) throw new UploadError(`Collection "${targetCollection}" does not support uploads. Make sure .upload() is enabled on the collection.`);
 			setProgress(0);
-			setError(null);
-			try {
-				const collectionApi = client.collections[targetCollection];
-				if (!collectionApi?.upload) throw new Error(`Collection "${targetCollection}" does not support uploads. Make sure .upload() is enabled on the collection.`);
-				const result = await collectionApi.upload(file, {
+			return {
+				asset: await collectionApi.upload(file, {
 					signal,
 					onProgress: (p) => {
 						setProgress(p);
 						onProgress?.(p);
 					}
-				});
-				queryClient.invalidateQueries({ queryKey: [
-					"questpie",
-					"collections",
-					targetCollection
-				] });
-				return result;
-			} catch (err) {
-				const uploadError = err instanceof Error ? err : /* @__PURE__ */ new Error("Upload failed");
-				setError(uploadError);
-				throw uploadError;
-			} finally {
-				setIsUploading(false);
-			}
-		}, [
-			client,
-			queryClient,
-			resolveTargetCollection,
-			getMissingCollectionMessage
-		]),
-		uploadMany: useCallback(async (files, options = {}) => {
-			const { to, onProgress, signal } = options;
-			const targetCollection = resolveTargetCollection(to);
-			if (!targetCollection) {
-				const missingCollectionError = new Error(getMissingCollectionMessage());
-				setError(missingCollectionError);
-				throw missingCollectionError;
-			}
-			if (files.length === 0) return [];
-			setIsUploading(true);
+				}),
+				targetCollection
+			};
+		};
+		$[4] = client;
+		$[5] = getMissingCollectionMessage;
+		$[6] = resolveTargetCollection;
+		$[7] = t2;
+	} else t2 = $[7];
+	let t3;
+	if ($[8] !== queryClient) {
+		t3 = (t4$1) => {
+			const { targetCollection: targetCollection_0 } = t4$1;
+			queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"collections",
+				targetCollection_0
+			] });
+		};
+		$[8] = queryClient;
+		$[9] = t3;
+	} else t3 = $[9];
+	let t4;
+	if ($[10] !== t2 || $[11] !== t3) {
+		t4 = {
+			mutationFn: t2,
+			onSuccess: t3
+		};
+		$[10] = t2;
+		$[11] = t3;
+		$[12] = t4;
+	} else t4 = $[12];
+	const uploadMutation = useMutation(t4);
+	let t5;
+	if ($[13] !== client || $[14] !== getMissingCollectionMessage || $[15] !== resolveTargetCollection) {
+		t5 = async (t6$1) => {
+			const { files, options: options_0 } = t6$1;
+			const { to: to_1, onProgress: onProgress_0, signal: signal_0 } = options_0 ?? {};
+			const targetCollection_1 = resolveTargetCollection(to_1);
+			if (!targetCollection_1) throw new Error(getMissingCollectionMessage());
+			if (files.length === 0) return {
+				assets: [],
+				targetCollection: targetCollection_1
+			};
+			const collectionApi_0 = client.collections[targetCollection_1];
+			if (!collectionApi_0?.uploadMany) throw new UploadError(`Collection "${targetCollection_1}" does not support uploads. Make sure .upload() is enabled on the collection.`);
 			setProgress(0);
-			setError(null);
-			try {
-				const collectionApi = client.collections[targetCollection];
-				if (!collectionApi?.uploadMany) throw new Error(`Collection "${targetCollection}" does not support uploads. Make sure .upload() is enabled on the collection.`);
-				const results = await collectionApi.uploadMany(files, {
-					signal,
-					onProgress: (p, fileIndex) => {
-						setProgress(p);
-						onProgress?.(p, fileIndex);
-					}
-				});
-				queryClient.invalidateQueries({ queryKey: [
-					"questpie",
-					"collections",
-					targetCollection
-				] });
-				setProgress(100);
-				return results;
-			} catch (err) {
-				const uploadError = err instanceof Error ? err : /* @__PURE__ */ new Error("Upload failed");
-				setError(uploadError);
-				throw uploadError;
-			} finally {
-				setIsUploading(false);
-			}
-		}, [
-			client,
-			queryClient,
-			resolveTargetCollection,
-			getMissingCollectionMessage
-		]),
-		isUploading,
-		progress,
-		error,
-		reset: useCallback(() => {
-			setIsUploading(false);
+			const results = await collectionApi_0.uploadMany(files, {
+				signal: signal_0,
+				onProgress: (p_0, fileIndex) => {
+					setProgress(p_0);
+					onProgress_0?.(p_0, fileIndex);
+				}
+			});
+			setProgress(100);
+			return {
+				assets: results,
+				targetCollection: targetCollection_1
+			};
+		};
+		$[13] = client;
+		$[14] = getMissingCollectionMessage;
+		$[15] = resolveTargetCollection;
+		$[16] = t5;
+	} else t5 = $[16];
+	let t6;
+	if ($[17] !== queryClient) {
+		t6 = (t7$1) => {
+			const { targetCollection: targetCollection_2 } = t7$1;
+			queryClient.invalidateQueries({ queryKey: [
+				"questpie",
+				"collections",
+				targetCollection_2
+			] });
+		};
+		$[17] = queryClient;
+		$[18] = t6;
+	} else t6 = $[18];
+	let t7;
+	if ($[19] !== t5 || $[20] !== t6) {
+		t7 = {
+			mutationFn: t5,
+			onSuccess: t6
+		};
+		$[19] = t5;
+		$[20] = t6;
+		$[21] = t7;
+	} else t7 = $[21];
+	const uploadManyMutation = useMutation(t7);
+	let t8;
+	if ($[22] !== uploadMutation) {
+		t8 = (file_0, options_1) => uploadMutation.mutateAsync({
+			file: file_0,
+			options: options_1
+		}).then(_temp);
+		$[22] = uploadMutation;
+		$[23] = t8;
+	} else t8 = $[23];
+	let t9;
+	if ($[24] !== uploadManyMutation) {
+		t9 = (files_0, options_2) => uploadManyMutation.mutateAsync({
+			files: files_0,
+			options: options_2
+		}).then(_temp2);
+		$[24] = uploadManyMutation;
+		$[25] = t9;
+	} else t9 = $[25];
+	const t10 = uploadMutation.isPending || uploadManyMutation.isPending;
+	const t11 = uploadMutation.error || uploadManyMutation.error || null;
+	let t12;
+	if ($[26] !== uploadManyMutation || $[27] !== uploadMutation) {
+		t12 = () => {
+			uploadMutation.reset();
+			uploadManyMutation.reset();
 			setProgress(0);
-			setError(null);
-		}, [])
-	};
+		};
+		$[26] = uploadManyMutation;
+		$[27] = uploadMutation;
+		$[28] = t12;
+	} else t12 = $[28];
+	let t13;
+	if ($[29] !== progress || $[30] !== t10 || $[31] !== t11 || $[32] !== t12 || $[33] !== t8 || $[34] !== t9) {
+		t13 = {
+			upload: t8,
+			uploadMany: t9,
+			isUploading: t10,
+			progress,
+			error: t11,
+			reset: t12
+		};
+		$[29] = progress;
+		$[30] = t10;
+		$[31] = t11;
+		$[32] = t12;
+		$[33] = t8;
+		$[34] = t9;
+		$[35] = t13;
+	} else t13 = $[35];
+	return t13;
+}
+function _temp2(r_0) {
+	return r_0.assets;
+}
+function _temp(r) {
+	return r.asset;
 }
 
 //#endregion
-export { useUpload };
-//# sourceMappingURL=use-upload.mjs.map
+export { useUpload };

package/dist/client/hooks/use-validation-error-map.mjs

@@ -1,6 +1,6 @@
 import { useSafeI18n } from "../i18n/hooks.mjs";
+import { c } from "react/compiler-runtime";
 import { createZodErrorMap } from "questpie/shared";
-import { useMemo } from "react";
 
 //#region src/client/hooks/use-validation-error-map.ts
 /**
@@ -34,8 +34,10 @@ import { useMemo } from "react";
 * ```
 */
 function useValidationErrorMap() {
+	const $ = c(2);
 	const i18n = useSafeI18n();
-	return useMemo(() => {
+	let t0;
+	if ($[0] !== i18n) {
 		const translate = (key, params) => {
 			if (i18n) return i18n.t(key, params);
 			if (!params) return key;
@@ -44,10 +46,12 @@ function useValidationErrorMap() {
 				return value !== void 0 ? String(value) : `{{${paramKey}}}`;
 			});
 		};
-		return createZodErrorMap(translate);
-	}, [i18n]);
+		t0 = createZodErrorMap(translate);
+		$[0] = i18n;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
 }
 
 //#endregion
-export { useValidationErrorMap };
-//# sourceMappingURL=use-validation-error-map.mjs.map
+export { useValidationErrorMap };