@canvas-digital/blog-sdk 2.0.0

package/dist/components/admin/mock/store.js

@@ -0,0 +1,1067 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { AdminSdkClient } from "../../../services/admin-sdk-client";
+import { getErrorMessage } from "../../../services/errors";
+import { mapAdminMeToProfile, mapAuthorToTerm, mapBrandToForm, mapCategoryToTerm, mapCommentToRow, mapMediaToHit, mapPostToRow, mapTagToTerm, postRowToWrite, } from "../api/mappers";
+import { createInitialFixtures, nextId, slugify, } from "./fixtures";
+const syncTermCounts = (state) => {
+    const countFor = (collection, termId) => state.posts.filter((p) => {
+        if (p.trashed)
+            return false;
+        if (collection === "categories")
+            return p.categoryIds.includes(termId);
+        if (collection === "tags")
+            return p.tagIds.includes(termId);
+        return p.authorIds.includes(termId);
+    }).length;
+    return {
+        ...state,
+        categories: state.categories.map((t) => ({ ...t, count: countFor("categories", t.id) })),
+        tags: state.tags.map((t) => ({ ...t, count: countFor("tags", t.id) })),
+        authors: state.authors.map((t) => ({ ...t, count: countFor("authors", t.id) })),
+    };
+};
+const resolveNames = (state, post) => {
+    const brand = state.brands.find((b) => b.id === post.brandId);
+    return {
+        ...post,
+        brandName: brand?.name ?? post.brandName,
+        brandSlug: brand?.slug ?? post.brandSlug,
+        categoryNames: post.categoryIds
+            .map((id) => state.categories.find((c) => c.id === id)?.name)
+            .filter(Boolean),
+        tagNames: post.tagIds
+            .map((id) => state.tags.find((t) => t.id === id)?.name)
+            .filter(Boolean),
+        authorNames: post.authorIds
+            .map((id) => state.authors.find((a) => a.id === id)?.name)
+            .filter(Boolean),
+    };
+};
+const AdminMockContext = createContext(null);
+const matchesPostFilter = (post, state) => {
+    switch (state) {
+        case "all":
+            return !post.trashed;
+        case "trash":
+            return post.trashed;
+        case "live":
+            return !post.trashed && post.status === "published";
+        case "writing":
+            return !post.trashed && post.status === "draft" && post.reviewState === "writing" && !post.scheduledFor;
+        case "review":
+            return !post.trashed && post.status === "draft" && post.reviewState === "in-review";
+        case "scheduled":
+            return !post.trashed && !!post.scheduledFor && post.status === "draft";
+        case "attention":
+            return (!post.trashed &&
+                post.status === "draft" &&
+                (post.reviewState === "in-review" || post.reviewState === "approved"));
+        default:
+            return !post.trashed;
+    }
+};
+export function AdminMockProvider({ children, config, }) {
+    const client = useMemo(() => config?.email && config.adminApiKey
+        ? new AdminSdkClient(config)
+        : null, [config?.apiUrl, config?.email, config?.adminApiKey, config?.domain, config?.timeoutMs]);
+    const live = Boolean(client);
+    const [data, setData] = useState(() => live
+        ? {
+            ...createInitialFixtures(),
+            brands: [],
+            posts: [],
+            categories: [],
+            tags: [],
+            authors: [],
+            comments: [],
+            media: [],
+        }
+        : createInitialFixtures());
+    const [activeBrandId, setActiveBrandId] = useState(null);
+    const [bootStatus, setBootStatus] = useState(live ? "loading" : "ready");
+    const [bootError, setBootError] = useState(null);
+    const clientRef = useRef(client);
+    clientRef.current = client;
+    const update = useCallback((fn) => {
+        setData((prev) => syncTermCounts(fn(prev)));
+    }, []);
+    const refreshFromApi = useCallback(async () => {
+        const api = clientRef.current;
+        if (!api || !config)
+            return;
+        setBootStatus((prev) => (prev === "ready" ? "ready" : "loading"));
+        try {
+            const [me, brandsPage, postsPage, catsPage, tagsPage, authorsPage, mediaPage, commentsPage] = await Promise.all([
+                api.me(),
+                api.listBrands({ pageSize: 100 }),
+                api.listPosts({ pageSize: 100, includeTrash: true }),
+                api.listCategories({ pageSize: 100 }),
+                api.listTags({ pageSize: 100 }),
+                api.listAuthors({ pageSize: 100 }),
+                api.listMedia({ pageSize: 100 }),
+                api.listComments({ pageSize: 100 }),
+            ]);
+            const brands = brandsPage.items.map(mapBrandToForm);
+            const categories = catsPage.items.map(mapCategoryToTerm);
+            const tags = tagsPage.items.map(mapTagToTerm);
+            const authors = authorsPage.items.map(mapAuthorToTerm);
+            const media = mediaPage.items.map(mapMediaToHit);
+            const posts = postsPage.items.map((p) => mapPostToRow(p, brands, categories, tags, authors));
+            const comments = commentsPage.items.map((c) => mapCommentToRow(c, posts, brands));
+            const profile = mapAdminMeToProfile(me);
+            const domainHint = config.domain?.trim().toLowerCase().replace(/^www\./, "") ?? "";
+            const resolved = (domainHint
+                ? brands.find((b) => b.primaryDomain.toLowerCase().replace(/^www\./, "") === domainHint)
+                : undefined) ?? brands[0];
+            setData((prev) => syncTermCounts({
+                ...prev,
+                profile,
+                brands,
+                categories,
+                tags,
+                authors,
+                media,
+                posts,
+                comments,
+            }));
+            setActiveBrandId((current) => current ?? resolved?.id ?? null);
+            setBootStatus("ready");
+            setBootError(null);
+        }
+        catch (error) {
+            setBootError(getErrorMessage(error));
+            setBootStatus((prev) => (prev === "ready" ? "ready" : "error"));
+            throw error;
+        }
+    }, [config]);
+    useEffect(() => {
+        if (!client || !config) {
+            setBootStatus("ready");
+            return;
+        }
+        setBootStatus("loading");
+        setBootError(null);
+        void refreshFromApi().catch(() => {
+            /* bootStatus/bootError set inside refreshFromApi */
+        });
+    }, [client, config, refreshFromApi]);
+    const brands = data.brands;
+    const activeBrand = brands.find((b) => b.id === activeBrandId) ?? null;
+    const filterPosts = useCallback(({ state = "all", query = "", categoryId, brandId }) => {
+        const q = query.trim().toLowerCase();
+        const brand = brandId === undefined ? activeBrandId : brandId;
+        return data.posts
+            .filter((p) => matchesPostFilter(p, state))
+            .filter((p) => (brand ? p.brandId === brand : true))
+            .filter((p) => (categoryId ? p.categoryIds.includes(categoryId) : true))
+            .filter((p) => (!q ? true : p.title.toLowerCase().includes(q) || p.slug.toLowerCase().includes(q)))
+            .map((p) => resolveNames(data, p))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }, [data, activeBrandId]);
+    const postCounts = useCallback((brandId) => {
+        const brand = brandId === undefined ? activeBrandId : brandId;
+        const scoped = data.posts.filter((p) => (brand ? p.brandId === brand : true));
+        const keys = [
+            "all",
+            "attention",
+            "writing",
+            "review",
+            "scheduled",
+            "live",
+            "trash",
+        ];
+        return Object.fromEntries(keys.map((k) => [k, scoped.filter((p) => matchesPostFilter(p, k)).length]));
+    }, [data.posts, activeBrandId]);
+    const getPost = useCallback((id) => {
+        const post = data.posts.find((p) => p.id === id);
+        return post ? resolveNames(data, post) : undefined;
+    }, [data]);
+    const savePost = useCallback((input) => {
+        if (!input.title.trim())
+            return { ok: false, error: "Title is required." };
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    const intent = input.status === "published"
+                        ? "publish"
+                        : input.scheduledFor
+                            ? "schedule"
+                            : "save";
+                    const body = postRowToWrite(input, intent);
+                    const saved = input.id
+                        ? await api.updatePost(input.id, body)
+                        : await api.createPost(body);
+                    await refreshFromApi();
+                    return { ok: true, id: saved.id };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        const id = input.id ?? nextId("post");
+        update((prev) => {
+            const existing = prev.posts.find((p) => p.id === id);
+            const brand = prev.brands.find((b) => b.id === input.brandId);
+            const next = resolveNames(prev, {
+                id,
+                title: input.title,
+                slug: input.slug || slugify(input.title),
+                status: input.status ?? existing?.status ?? "draft",
+                reviewState: input.reviewState ?? existing?.reviewState ?? "writing",
+                scheduledFor: input.scheduledFor ?? existing?.scheduledFor ?? null,
+                publishedAt: input.publishedAt ?? existing?.publishedAt ?? null,
+                updatedAt: new Date().toISOString(),
+                createdAt: existing?.createdAt ?? new Date().toISOString(),
+                trashed: input.trashed ?? existing?.trashed ?? false,
+                categoryIds: input.categoryIds ?? existing?.categoryIds ?? [],
+                categoryNames: [],
+                tagIds: input.tagIds ?? existing?.tagIds ?? [],
+                tagNames: [],
+                authorIds: input.authorIds ?? existing?.authorIds ?? [],
+                authorNames: [],
+                brandId: input.brandId,
+                brandName: brand?.name ?? null,
+                brandSlug: brand?.slug ?? null,
+                blockers: input.blockers ?? existing?.blockers ?? [],
+                readingMinutes: input.readingMinutes ?? existing?.readingMinutes ?? null,
+                views: input.views ?? existing?.views ?? null,
+                canPublish: true,
+                excerpt: input.excerpt ?? existing?.excerpt ?? "",
+                contentHtml: input.contentHtml ?? existing?.contentHtml ?? "",
+                featuredImageId: input.featuredImageId ?? existing?.featuredImageId ?? null,
+                allowComments: input.allowComments ?? existing?.allowComments ?? true,
+                visibility: input.visibility ?? existing?.visibility ?? "public",
+                template: input.template ?? existing?.template ?? "default",
+                authorBox: input.authorBox ?? existing?.authorBox ?? "default",
+                showInTableOfContents: input.showInTableOfContents ?? existing?.showInTableOfContents ?? true,
+                postFormat: input.postFormat ?? existing?.postFormat ?? "standard",
+                seo: input.seo ??
+                    existing?.seo ?? {
+                    metaTitle: "",
+                    metaDescription: "",
+                    focusKeyphrase: "",
+                    noindex: false,
+                },
+            });
+            const posts = existing
+                ? prev.posts.map((p) => (p.id === id ? next : p))
+                : [next, ...prev.posts];
+            return { ...prev, posts };
+        });
+        return { ok: true, id };
+    }, [update, refreshFromApi]);
+    const patchPost = useCallback((id, fn) => {
+        let found = false;
+        update((prev) => {
+            const posts = prev.posts.map((p) => {
+                if (p.id !== id)
+                    return p;
+                found = true;
+                return resolveNames(prev, { ...fn(p), updatedAt: new Date().toISOString() });
+            });
+            return { ...prev, posts };
+        });
+        return found ? { ok: true } : { ok: false, error: "Post not found." };
+    }, [update]);
+    const bulkPostAction = useCallback((ids, action) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    for (const id of ids) {
+                        if (action === "publish")
+                            await api.publishPost(id);
+                        else if (action === "draft")
+                            await api.unpublishPost(id);
+                        else if (action === "trash")
+                            await api.deletePost(id, false);
+                        else if (action === "delete")
+                            await api.deletePost(id, true);
+                        else if (action === "restore")
+                            await api.updatePost(id, { intent: "restore" });
+                        else if (action === "submit")
+                            await api.updatePost(id, { reviewState: "in-review" });
+                        else if (action === "approve")
+                            await api.updatePost(id, { reviewState: "approved" });
+                        else if (action === "send-back")
+                            await api.updatePost(id, { reviewState: "writing" });
+                    }
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        update((prev) => {
+            let posts = [...prev.posts];
+            for (const id of ids) {
+                const i = posts.findIndex((p) => p.id === id);
+                if (i < 0)
+                    continue;
+                const p = posts[i];
+                if (action === "delete") {
+                    posts = posts.filter((x) => x.id !== id);
+                    continue;
+                }
+                let next = { ...p, updatedAt: new Date().toISOString() };
+                if (action === "trash")
+                    next.trashed = true;
+                if (action === "restore")
+                    next.trashed = false;
+                if (action === "submit")
+                    next.reviewState = "in-review";
+                if (action === "approve")
+                    next.reviewState = "approved";
+                if (action === "send-back")
+                    next.reviewState = "writing";
+                if (action === "publish") {
+                    next.status = "published";
+                    next.reviewState = "approved";
+                    next.scheduledFor = null;
+                    next.publishedAt = next.publishedAt ?? new Date().toISOString();
+                }
+                if (action === "draft") {
+                    next.status = "draft";
+                    next.scheduledFor = null;
+                }
+                posts[i] = next;
+            }
+            return { ...prev, posts };
+        });
+        return { ok: true };
+    }, [update, refreshFromApi]);
+    const submitForReview = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.updatePost(id, { reviewState: "in-review" });
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({ ...p, reviewState: "in-review" }));
+    }, [patchPost, refreshFromApi]);
+    const approve = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.updatePost(id, { reviewState: "approved" });
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({ ...p, reviewState: "approved" }));
+    }, [patchPost, refreshFromApi]);
+    const sendBack = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.updatePost(id, { reviewState: "writing" });
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({ ...p, reviewState: "writing" }));
+    }, [patchPost, refreshFromApi]);
+    const publishNow = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.publishPost(id);
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({
+            ...p,
+            status: "published",
+            reviewState: "approved",
+            scheduledFor: null,
+            publishedAt: p.publishedAt ?? new Date().toISOString(),
+        }));
+    }, [patchPost, refreshFromApi]);
+    const unpublish = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.unpublishPost(id);
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({ ...p, status: "draft", scheduledFor: null }));
+    }, [patchPost, refreshFromApi]);
+    const schedulePost = useCallback((id, when) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.updatePost(id, {
+                        scheduledAt: when,
+                        status: "draft",
+                        reviewState: "approved",
+                        intent: "schedule",
+                    });
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        return patchPost(id, (p) => ({
+            ...p,
+            scheduledFor: when,
+            status: "draft",
+            reviewState: "approved",
+        }));
+    }, [patchPost, refreshFromApi]);
+    const duplicatePost = useCallback((id) => {
+        const src = data.posts.find((p) => p.id === id);
+        if (!src)
+            return { ok: false, error: "Post not found." };
+        const copyId = nextId("post");
+        update((prev) => ({
+            ...prev,
+            posts: [
+                resolveNames(prev, {
+                    ...src,
+                    id: copyId,
+                    title: `${src.title} (copy)`,
+                    slug: `${src.slug}-copy`,
+                    status: "draft",
+                    reviewState: "writing",
+                    publishedAt: null,
+                    scheduledFor: null,
+                    trashed: false,
+                    views: null,
+                    updatedAt: new Date().toISOString(),
+                    createdAt: new Date().toISOString(),
+                }),
+                ...prev.posts,
+            ],
+        }));
+        return { ok: true };
+    }, [data.posts, update]);
+    const quickEditPost = useCallback((input) => patchPost(input.id, (p) => ({
+        ...p,
+        title: input.title,
+        slug: input.slug || slugify(input.title),
+        categoryIds: input.category,
+        publishedAt: input.publishedAt,
+        scheduledFor: input.scheduledFor,
+        status: input.status,
+    })), [patchPost]);
+    const terms = useCallback((collection, brandId) => {
+        const brand = brandId === undefined ? activeBrandId : brandId;
+        const list = collection === "categories"
+            ? data.categories
+            : collection === "tags"
+                ? data.tags
+                : data.authors;
+        return list.filter((t) => (brand ? t.brandId === brand : true));
+    }, [data, activeBrandId]);
+    const saveTerm = useCallback((input) => {
+        if (!input.name.trim())
+            return { ok: false, error: "Name is required." };
+        if (!input.brandId)
+            return { ok: false, error: "Pick a brand first." };
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    const base = {
+                        name: input.name.trim(),
+                        slug: input.slug?.trim() || slugify(input.name),
+                        description: input.description,
+                        brandId: input.brandId,
+                    };
+                    let savedId;
+                    if (input.collection === "categories") {
+                        const saved = input.id
+                            ? await api.updateCategory(input.id, base)
+                            : await api.createCategory(base);
+                        savedId = saved.id;
+                    }
+                    else if (input.collection === "tags") {
+                        const saved = input.id
+                            ? await api.updateTag(input.id, base)
+                            : await api.createTag(base);
+                        savedId = saved.id;
+                    }
+                    else {
+                        const authorBody = {
+                            ...base,
+                            jobTitle: input.jobTitle,
+                            bio: input.bio,
+                        };
+                        const saved = input.id
+                            ? await api.updateAuthor(input.id, authorBody)
+                            : await api.createAuthor(authorBody);
+                        savedId = saved.id;
+                    }
+                    await refreshFromApi();
+                    return { ok: true, id: savedId };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        const id = input.id ?? nextId(input.collection.slice(0, 3));
+        const row = {
+            id,
+            name: input.name.trim(),
+            slug: input.slug?.trim() || slugify(input.name),
+            description: input.description ?? "",
+            jobTitle: input.jobTitle ?? "",
+            bio: input.bio ?? "",
+            count: 0,
+            brandId: input.brandId,
+        };
+        update((prev) => {
+            const key = input.collection === "categories"
+                ? "categories"
+                : input.collection === "tags"
+                    ? "tags"
+                    : "authors";
+            const list = prev[key];
+            const exists = list.some((t) => t.id === id);
+            return {
+                ...prev,
+                [key]: exists ? list.map((t) => (t.id === id ? { ...row, count: t.count } : t)) : [row, ...list],
+            };
+        });
+        return { ok: true, id };
+    }, [update, refreshFromApi]);
+    const deleteTerm = useCallback((collection, id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    if (collection === "categories")
+                        await api.deleteCategory(id, true);
+                    else if (collection === "tags")
+                        await api.deleteTag(id, true);
+                    else
+                        await api.deleteAuthor(id, true);
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        const key = collection === "categories" ? "categories" : collection === "tags" ? "tags" : "authors";
+        if (collection !== "tags") {
+            const inUse = data.posts.some((p) => {
+                if (p.trashed)
+                    return false;
+                if (collection === "categories")
+                    return p.categoryIds.includes(id);
+                return p.authorIds.includes(id);
+            });
+            if (inUse)
+                return { ok: false, error: "Still in use by posts — reassign first." };
+        }
+        update((prev) => {
+            const next = { ...prev, [key]: prev[key].filter((t) => t.id !== id) };
+            if (collection === "tags") {
+                next.posts = prev.posts.map((p) => ({
+                    ...p,
+                    tagIds: p.tagIds.filter((tid) => tid !== id),
+                }));
+            }
+            return next;
+        });
+        return { ok: true };
+    }, [data.posts, update, refreshFromApi]);
+    const listMedia = useCallback((brandId, query, page, pageSize = 24) => {
+        const q = query.trim().toLowerCase();
+        const brand = brandId ?? activeBrandId;
+        const filtered = data.media
+            .filter((m) => (brand ? m.brandId === brand : true))
+            .filter((m) => !q ? true : m.alt.toLowerCase().includes(q) || m.filename.toLowerCase().includes(q))
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+        const start = (page - 1) * pageSize;
+        const items = filtered.slice(start, start + pageSize);
+        return { items, total: filtered.length, hasMore: start + pageSize < filtered.length };
+    }, [data.media, activeBrandId]);
+    const uploadMedia = useCallback(async (files, brandId) => {
+        const brand = brandId ?? activeBrandId ?? data.brands[0]?.id;
+        if (!brand)
+            return { ok: false, error: "No brand selected.", images: [] };
+        const api = clientRef.current;
+        const list = Array.from(files);
+        if (api) {
+            try {
+                const images = [];
+                for (const file of list) {
+                    const saved = await api.uploadMedia(file, brand);
+                    images.push(mapMediaToHit(saved));
+                }
+                await refreshFromApi();
+                return { ok: true, images };
+            }
+            catch (error) {
+                return { ok: false, error: getErrorMessage(error), images: [] };
+            }
+        }
+        const images = [];
+        for (const file of list) {
+            const url = await new Promise((resolve, reject) => {
+                const reader = new FileReader();
+                reader.onload = () => resolve(String(reader.result));
+                reader.onerror = () => reject(new Error("Read failed"));
+                reader.readAsDataURL(file);
+            });
+            const alt = file.name.replace(/\.[^.]+$/, "").replace(/[-_]/g, " ");
+            const hit = {
+                id: nextId("media"),
+                url,
+                thumbUrl: url,
+                alt,
+                filename: file.name,
+                width: null,
+                height: null,
+                filesize: file.size,
+                createdAt: new Date().toISOString(),
+                brandId: brand,
+                caption: "",
+                credit: "",
+            };
+            images.push(hit);
+        }
+        update((prev) => ({ ...prev, media: [...images, ...prev.media] }));
+        return { ok: true, images };
+    }, [activeBrandId, data.brands, update, refreshFromApi]);
+    const updateMedia = useCallback((id, meta) => {
+        if (!meta.alt.trim())
+            return { ok: false, error: "Alt text is required." };
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.updateMedia(id, meta);
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        update((prev) => ({
+            ...prev,
+            media: prev.media.map((m) => (m.id === id ? { ...m, ...meta } : m)),
+        }));
+        return { ok: true };
+    }, [update, refreshFromApi]);
+    const deleteMedia = useCallback((id) => {
+        const api = clientRef.current;
+        if (api) {
+            return (async () => {
+                try {
+                    await api.deleteMedia(id);
+                    await refreshFromApi();
+                    return { ok: true };
+                }
+                catch (error) {
+                    return { ok: false, error: getErrorMessage(error) };
+                }
+            })();
+        }
+        update((prev) => ({ ...prev, media: prev.media.filter((m) => m.id !== id) }));
+        return { ok: true };
+    }, [update, refreshFromApi]);
+    const comments = useCallback((brandId) => {
+        const brand = brandId === undefined ? activeBrandId : brandId;
+        return data.comments.filter((c) => (brand ? c.brandId === brand : true));
+    }, [data.comments, activeBrandId]);
+    const setCommentStatus = useCallback((id, status) => {
+        update((prev) => ({
+            ...prev,
+            comments: prev.comments.map((c) => (c.id === id ? { ...c, status } : c)),
+        }));
+        return { ok: true };
+    }, [update]);
+    const deleteComment = useCallback((id) => {
+        update((prev) => ({ ...prev, comments: prev.comments.filter((c) => c.id !== id) }));
+        return { ok: true };
+    }, [update]);
+    const users = useCallback(() => data.users, [data.users]);
+    const saveUser = useCallback((input) => {
+        if (!input.name.trim() || !input.email.trim()) {
+            return { ok: false, error: "Name and email are required." };
+        }
+        if (!input.id && (!input.password || input.password.length < 12)) {
+            return { ok: false, error: "Password must be at least 12 characters." };
+        }
+        if (input.id && input.password && input.password.length > 0 && input.password.length < 12) {
+            return { ok: false, error: "Password must be at least 12 characters." };
+        }
+        update((prev) => {
+            const roles = input.tenantRoles.map((r) => ({
+                tenant: r.tenant,
+                tenantName: prev.brands.find((b) => b.id === r.tenant)?.name ?? r.tenant,
+                role: r.role,
+            }));
+            if (input.id) {
+                return {
+                    ...prev,
+                    users: prev.users.map((u) => u.id === input.id
+                        ? { ...u, name: input.name, email: input.email, globalRole: input.globalRole, roles }
+                        : u),
+                };
+            }
+            const row = {
+                id: nextId("user"),
+                name: input.name,
+                email: input.email,
+                globalRole: input.globalRole,
+                roles,
+                isSelf: false,
+            };
+            return { ...prev, users: [row, ...prev.users] };
+        });
+        return { ok: true };
+    }, [update]);
+    const deleteUser = useCallback((id) => {
+        const row = data.users.find((u) => u.id === id);
+        if (!row)
+            return { ok: false, error: "User not found." };
+        if (row.isSelf)
+            return { ok: false, error: "You cannot delete your own account." };
+        update((prev) => ({ ...prev, users: prev.users.filter((u) => u.id !== id) }));
+        return { ok: true };
+    }, [data.users, update]);
+    const saveBrand = useCallback((brand) => {
+        if (!brand.name.trim())
+            return { ok: false, error: "Brand name is required." };
+        update((prev) => ({
+            ...prev,
+            brands: prev.brands.map((b) => (b.id === brand.id ? { ...brand } : b)),
+        }));
+        return { ok: true };
+    }, [update]);
+    const redirects = useCallback((brandId) => {
+        const brand = brandId === undefined ? activeBrandId : brandId;
+        return data.redirects.filter((r) => (brand ? r.brandId === brand : true));
+    }, [data.redirects, activeBrandId]);
+    const getRedirect = useCallback((id) => data.redirects.find((r) => r.id === id), [data.redirects]);
+    const saveRedirect = useCallback((input) => {
+        if (!input.from.trim())
+            return { ok: false, error: "From path is required." };
+        const terminal = new Set(["404", "410", "451"]);
+        if (!terminal.has(input.type) && !input.to?.trim()) {
+            return { ok: false, error: "Target URL is required for this redirect type." };
+        }
+        const id = input.id ?? nextId("redir");
+        const brand = data.brands.find((b) => b.id === input.brandId);
+        update((prev) => {
+            const row = {
+                id,
+                from: input.from.trim(),
+                to: input.to?.trim() ?? "",
+                type: input.type,
+                source: input.source ?? "manual",
+                active: input.active ?? true,
+                note: input.note ?? null,
+                brandId: input.brandId,
+                brandName: brand?.name ?? null,
+                brandSlug: brand?.slug ?? null,
+                updatedAt: new Date().toISOString(),
+                match: input.match ?? "exact",
+                ignoreCase: input.ignoreCase ?? true,
+                ignoreTrailingSlash: input.ignoreTrailingSlash ?? true,
+                forceHttps: input.forceHttps ?? true,
+                preserveQuery: input.preserveQuery ?? true,
+                wildcardMatch: input.wildcardMatch ?? false,
+            };
+            const exists = prev.redirects.some((r) => r.id === id);
+            return {
+                ...prev,
+                redirects: exists
+                    ? prev.redirects.map((r) => (r.id === id ? row : r))
+                    : [row, ...prev.redirects],
+                redirectAnalytics: {
+                    ...prev.redirectAnalytics,
+                    totalRules: exists
+                        ? prev.redirectAnalytics.totalRules
+                        : prev.redirectAnalytics.totalRules + 1,
+                },
+            };
+        });
+        return { ok: true };
+    }, [data.brands, update]);
+    const deleteRedirect = useCallback((id) => {
+        update((prev) => ({
+            ...prev,
+            redirects: prev.redirects.filter((r) => r.id !== id),
+            redirectAnalytics: {
+                ...prev.redirectAnalytics,
+                totalRules: Math.max(0, prev.redirectAnalytics.totalRules - 1),
+            },
+        }));
+        return { ok: true };
+    }, [update]);
+    const getRobots = useCallback((brandId) => data.robots[brandId] ?? {
+        allowPaths: ["/blog"],
+        disallowPaths: ["/admin"],
+        includeSitemap: true,
+        extraRules: "",
+    }, [data.robots]);
+    const saveRobots = useCallback((brandId, config) => {
+        update((prev) => ({ ...prev, robots: { ...prev.robots, [brandId]: config } }));
+        return { ok: true };
+    }, [update]);
+    const saveGa4 = useCallback((brandId, ga4MeasurementId) => {
+        update((prev) => ({
+            ...prev,
+            brands: prev.brands.map((b) => (b.id === brandId ? { ...b, ga4MeasurementId } : b)),
+        }));
+        return { ok: true };
+    }, [update]);
+    const saveGsc = useCallback((brandId, gscVerification) => {
+        update((prev) => ({
+            ...prev,
+            brands: prev.brands.map((b) => (b.id === brandId ? { ...b, gscVerification } : b)),
+        }));
+        return { ok: true };
+    }, [update]);
+    const saveSettings = useCallback((next) => {
+        update((prev) => ({ ...prev, settings: next }));
+        return { ok: true };
+    }, [update]);
+    const exportPayload = useCallback((kind, format, brandId) => {
+        const brand = brandId ?? activeBrandId;
+        const posts = data.posts.filter((p) => (brand ? p.brandId === brand : true) && !p.trashed);
+        const media = data.media.filter((m) => (brand ? m.brandId === brand : true));
+        const payload = kind === "posts" ? { posts } : kind === "media" ? { media } : { posts, media };
+        if (format === "json")
+            return JSON.stringify(payload, null, 2);
+        if (format === "csv") {
+            const lines = ["recordType,id,title"];
+            if (kind === "all" || kind === "posts") {
+                for (const p of posts)
+                    lines.push(`post,${p.id},"${p.title.replace(/"/g, '""')}"`);
+            }
+            if (kind === "all" || kind === "media") {
+                for (const m of media)
+                    lines.push(`media,${m.id},"${m.filename.replace(/"/g, '""')}"`);
+            }
+            return lines.join("\n");
+        }
+        return `<export>${JSON.stringify(payload)}</export>`;
+    }, [data, activeBrandId]);
+    const importPayload = useCallback((content, kind, brandId) => {
+        const result = {
+            postsCreated: 0,
+            postsSkipped: 0,
+            commentsCreated: 0,
+            commentsSkipped: 0,
+            errors: [],
+        };
+        try {
+            const parsed = JSON.parse(content);
+            if (kind === "all" || kind === "posts") {
+                for (const row of parsed.posts ?? []) {
+                    if (!row.title) {
+                        result.postsSkipped += 1;
+                        continue;
+                    }
+                    const slug = row.slug || slugify(row.title);
+                    if (data.posts.some((p) => p.slug === slug && p.brandId === brandId)) {
+                        result.postsSkipped += 1;
+                        continue;
+                    }
+                    savePost({
+                        title: row.title,
+                        slug,
+                        brandId,
+                        contentHtml: row.contentHtml ?? "",
+                        status: "draft",
+                        reviewState: "writing",
+                    });
+                    result.postsCreated += 1;
+                }
+            }
+            if (kind === "all" || kind === "comments") {
+                for (const row of parsed.comments ?? []) {
+                    if (!row.body || !row.postSlug) {
+                        result.commentsSkipped += 1;
+                        continue;
+                    }
+                    const post = data.posts.find((p) => p.slug === row.postSlug && p.brandId === brandId);
+                    if (!post) {
+                        result.commentsSkipped += 1;
+                        result.errors.push(`No post for slug ${row.postSlug}`);
+                        continue;
+                    }
+                    update((prev) => ({
+                        ...prev,
+                        comments: [
+                            {
+                                id: nextId("cmt"),
+                                authorName: row.authorName || "Imported",
+                                authorEmail: null,
+                                body: row.body,
+                                status: "pending",
+                                createdAt: new Date().toISOString(),
+                                postId: post.id,
+                                postTitle: post.title,
+                                postOwnerId: prev.profile.id,
+                                brandId,
+                                brandName: prev.brands.find((b) => b.id === brandId)?.name ?? null,
+                            },
+                            ...prev.comments,
+                        ],
+                    }));
+                    result.commentsCreated += 1;
+                }
+            }
+        }
+        catch {
+            result.errors.push("Could not parse import file as JSON.");
+        }
+        return result;
+    }, [data.posts, savePost, update]);
+    const value = useMemo(() => ({
+        data,
+        profile: data.profile,
+        activeBrandId,
+        setActiveBrandId,
+        brands,
+        activeBrand,
+        filterPosts,
+        postCounts,
+        getPost,
+        savePost,
+        bulkPostAction,
+        submitForReview,
+        approve,
+        sendBack,
+        publishNow,
+        unpublish,
+        schedulePost,
+        duplicatePost,
+        quickEditPost,
+        terms,
+        saveTerm,
+        deleteTerm,
+        listMedia,
+        uploadMedia,
+        updateMedia,
+        deleteMedia,
+        comments,
+        setCommentStatus,
+        deleteComment,
+        users,
+        saveUser,
+        deleteUser,
+        saveBrand,
+        redirects,
+        getRedirect,
+        saveRedirect,
+        deleteRedirect,
+        redirectAnalytics: data.redirectAnalytics,
+        getRobots,
+        saveRobots,
+        saveGa4,
+        saveGsc,
+        settings: data.settings,
+        saveSettings,
+        exportPayload,
+        importPayload,
+        live,
+        bootStatus,
+        bootError,
+        refreshFromApi,
+    }), [
+        data,
+        activeBrandId,
+        brands,
+        activeBrand,
+        filterPosts,
+        postCounts,
+        getPost,
+        savePost,
+        bulkPostAction,
+        submitForReview,
+        approve,
+        sendBack,
+        publishNow,
+        unpublish,
+        schedulePost,
+        duplicatePost,
+        quickEditPost,
+        terms,
+        saveTerm,
+        deleteTerm,
+        listMedia,
+        uploadMedia,
+        updateMedia,
+        deleteMedia,
+        comments,
+        setCommentStatus,
+        deleteComment,
+        users,
+        saveUser,
+        deleteUser,
+        saveBrand,
+        redirects,
+        getRedirect,
+        saveRedirect,
+        deleteRedirect,
+        getRobots,
+        saveRobots,
+        saveGa4,
+        saveGsc,
+        saveSettings,
+        exportPayload,
+        importPayload,
+        live,
+        bootStatus,
+        bootError,
+        refreshFromApi,
+    ]);
+    return _jsx(AdminMockContext.Provider, { value: value, children: children });
+}
+export function useAdminMock() {
+    const ctx = useContext(AdminMockContext);
+    if (!ctx)
+        throw new Error("useAdminMock must be used within AdminMockProvider");
+    return ctx;
+}