@questpie/admin 1.1.1 → 3.0.0

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

@@ -0,0 +1,31 @@
+import { useAdminConfig } from "./use-admin-config.mjs";
+import { useMemo } from "react";
+
+//#region src/client/hooks/use-upload-collection.ts
+function normalizeCollectionName(value) {
+	if (typeof value !== "string") return void 0;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+function resolveUploadCollection(preferred, uploads) {
+	const preferredCollection = normalizeCollectionName(preferred);
+	if (preferredCollection) return preferredCollection;
+	const defaultCollection = normalizeCollectionName(uploads?.defaultCollection);
+	if (defaultCollection) return defaultCollection;
+	if (uploads?.collections?.length === 1) return uploads.collections[0];
+}
+function useUploadCollection(preferred) {
+	const { data: adminConfig } = useAdminConfig();
+	const collections = adminConfig?.uploads?.collections ?? [];
+	return useMemo(() => ({
+		collection: resolveUploadCollection(preferred, adminConfig?.uploads),
+		collections
+	}), [
+		preferred,
+		collections.join("|"),
+		adminConfig?.uploads?.defaultCollection
+	]);
+}
+
+//#endregion
+export { useUploadCollection };

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

@@ -0,0 +1,209 @@
+import { selectClient, useAdminStore } from "../runtime/provider.mjs";
+import { useUploadCollection } from "./use-upload-collection.mjs";
+import { c } from "react/compiler-runtime";
+import { useState } from "react";
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+
+//#region src/client/hooks/use-upload.ts
+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 [progress, setProgress] = useState(0);
+	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);
+			return {
+				asset: await collectionApi.upload(file, {
+					signal,
+					onProgress: (p) => {
+						setProgress(p);
+						onProgress?.(p);
+					}
+				}),
+				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);
+			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);
+		};
+		$[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 };

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

@@ -0,0 +1,57 @@
+import { useSafeI18n } from "../i18n/hooks.mjs";
+import { c } from "react/compiler-runtime";
+import { createZodErrorMap } from "questpie/shared";
+
+//#region src/client/hooks/use-validation-error-map.ts
+/**
+* useValidationErrorMap Hook
+*
+* Creates a Zod error map that uses the admin i18n system
+* for localized validation error messages.
+*/
+/**
+* Create a Zod error map with i18n support
+*
+* Uses the admin's i18n adapter for translations.
+* Falls back to English messages if no adapter is available.
+*
+* @returns Zod error map function
+*
+* @example
+* ```tsx
+* import { zodResolver } from "@hookform/resolvers/zod";
+*
+* function MyForm() {
+*   const errorMap = useValidationErrorMap();
+*   const schema = useCollectionValidation("posts");
+*
+*   const form = useForm({
+*     resolver: schema
+*       ? zodResolver(schema, { errorMap })
+*       : undefined,
+*   });
+* }
+* ```
+*/
+function useValidationErrorMap() {
+	const $ = c(2);
+	const i18n = useSafeI18n();
+	let t0;
+	if ($[0] !== i18n) {
+		const translate = (key, params) => {
+			if (i18n) return i18n.t(key, params);
+			if (!params) return key;
+			return key.replace(/\{\{(\w+)\}\}/g, (_, paramKey) => {
+				const value = params[paramKey];
+				return value !== void 0 ? String(value) : `{{${paramKey}}}`;
+			});
+		};
+		t0 = createZodErrorMap(translate);
+		$[0] = i18n;
+		$[1] = t0;
+	} else t0 = $[1];
+	return t0;
+}
+
+//#endregion
+export { useValidationErrorMap };