@foxpixel/react 0.1.0 → 0.2.0

package/dist/index.js

@@ -31,15 +31,46 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthProvider: () => AuthProvider,
+  Editable: () => Editable,
+  EditableHTML: () => EditableHTML,
+  EditableImage: () => EditableImage,
   FoxPixelHttpClient: () => FoxPixelHttpClient,
   FoxPixelProvider: () => FoxPixelProvider,
   GuestOnlyRoute: () => GuestOnlyRoute,
   ProtectedRoute: () => ProtectedRoute,
+  SITE_CONTENT_QUERY_KEY: () => SITE_CONTENT_QUERY_KEY,
+  getBlogPostSchemaLd: () => getBlogPostSchemaLd,
+  useAdminBlogAnalytics: () => useAdminBlogAnalytics,
+  useAdminBlogCategories: () => useAdminBlogCategories,
+  useAdminBlogComments: () => useAdminBlogComments,
+  useAdminBlogPost: () => useAdminBlogPost,
+  useAdminBlogPostMutations: () => useAdminBlogPostMutations,
+  useAdminBlogPosts: () => useAdminBlogPosts,
+  useAdminBlogSettings: () => useAdminBlogSettings,
+  useAdminBlogTags: () => useAdminBlogTags,
+  useAdminNewsletterStats: () => useAdminNewsletterStats,
+  useAdminNewsletterSubscribers: () => useAdminNewsletterSubscribers,
   useAuth: () => useAuth,
+  useBlogCategories: () => useBlogCategories,
+  useBlogCommentSubmit: () => useBlogCommentSubmit,
+  useBlogComments: () => useBlogComments,
+  useBlogFeaturedPosts: () => useBlogFeaturedPosts,
+  useBlogPost: () => useBlogPost,
+  useBlogPosts: () => useBlogPosts,
+  useBlogTags: () => useBlogTags,
   useContactCapture: () => useContactCapture,
+  useEditMode: () => useEditMode,
+  useEditModeMessaging: () => useEditModeMessaging,
   useFoxPixelContext: () => useFoxPixelContext,
   useLeadCapture: () => useLeadCapture,
+  useNewsletterSubscribe: () => useNewsletterSubscribe,
+  useNewsletterUnsubscribe: () => useNewsletterUnsubscribe,
+  useSendEditRequest: () => useSendEditRequest,
   useServices: () => useServices,
+  useSiteContent: () => useSiteContent,
+  useSiteContentQuery: () => useSiteContentQuery,
+  useSiteContentSection: () => useSiteContentSection,
+  useSiteContents: () => useSiteContents,
   withAuth: () => withAuth
 });
 module.exports = __toCommonJS(index_exports);
@@ -284,7 +315,8 @@ function AuthProvider({
     logout,
     register,
     updateProfile,
-    refetch: fetchCurrentUser
+    refetch: fetchCurrentUser,
+    hasPermission: (permission) => user !== null && permission === "site:content:update"
   };
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(AuthContext.Provider, { value, children });
 }
@@ -390,13 +422,332 @@ function withAuth(Component, options = {}) {
   };
 }
 
-// src/hooks/useServices.ts
+// src/components/Editable.tsx
+var import_react7 = require("react");
+
+// src/hooks/useEditMode.ts
 var import_react6 = require("react");
+var import_react_query = require("@tanstack/react-query");
+var SITE_CONTENT_QUERY_KEY = "siteContent";
+function useEditMode() {
+  const [isEditMode, setIsEditMode] = (0, import_react6.useState)(false);
+  (0, import_react6.useEffect)(() => {
+    if (typeof window === "undefined") return;
+    const params = new URLSearchParams(window.location.search);
+    setIsEditMode(params.get("edit-mode") === "true");
+  }, []);
+  return isEditMode;
+}
+function useEditModeMessaging() {
+  const queryClient = (0, import_react_query.useQueryClient)();
+  const isEditMode = useEditMode();
+  (0, import_react6.useEffect)(() => {
+    if (!isEditMode || typeof window === "undefined") return;
+    window.parent.postMessage({ type: "FOXPIXEL_READY" }, "*");
+    const handleMessage = (event) => {
+      const { type, payload } = event.data || {};
+      if (type === "FOXPIXEL_CONTENT_UPDATED" && payload?.contentKey) {
+        queryClient.invalidateQueries({
+          queryKey: [SITE_CONTENT_QUERY_KEY, payload.contentKey]
+        });
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, [isEditMode, queryClient]);
+  return isEditMode;
+}
+function useSendEditRequest() {
+  const isEditMode = useEditMode();
+  return (0, import_react6.useCallback)(
+    (contentKey, currentValue, contentType = "text", section, description) => {
+      if (!isEditMode) return;
+      if (typeof window !== "undefined" && window.parent !== window) {
+        window.parent.postMessage(
+          {
+            type: "FOXPIXEL_EDIT_CONTENT",
+            payload: {
+              contentKey,
+              currentValue,
+              contentType,
+              section,
+              description
+            }
+          },
+          "*"
+        );
+      }
+    },
+    [isEditMode]
+  );
+}
+
+// src/hooks/useSiteContentQuery.ts
+var import_react_query2 = require("@tanstack/react-query");
+function useSiteContentQuery(contentKey, options) {
+  const { defaultValue } = options;
+  const { client } = useFoxPixelContext();
+  const { data, isLoading } = (0, import_react_query2.useQuery)({
+    queryKey: [SITE_CONTENT_QUERY_KEY, contentKey],
+    queryFn: async () => {
+      try {
+        const content = await client.get(
+          `/api/site/content/${encodeURIComponent(contentKey)}`
+        );
+        if (!content) return null;
+        return {
+          value: content.value ?? "",
+          contentType: content.contentType ?? "TEXT"
+        };
+      } catch (err) {
+        const status = err?.status;
+        if (status === 404) return null;
+        throw err;
+      }
+    },
+    staleTime: 1e3 * 60 * 5,
+    retry: 1
+  });
+  return {
+    value: data?.value ?? defaultValue,
+    isLoading,
+    contentType: data?.contentType ?? "TEXT"
+  };
+}
+
+// src/utils/sanitize.ts
+var import_isomorphic_dompurify = __toESM(require("isomorphic-dompurify"));
+var DEFAULT_ALLOWED_TAGS = [
+  "p",
+  "br",
+  "strong",
+  "em",
+  "u",
+  "s",
+  "a",
+  "ul",
+  "ol",
+  "li",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "blockquote",
+  "code",
+  "pre",
+  "span",
+  "div",
+  "img",
+  "table",
+  "thead",
+  "tbody",
+  "tr",
+  "th",
+  "td"
+];
+var DEFAULT_ALLOWED_ATTR = ["href", "target", "rel", "src", "alt", "title", "class"];
+function sanitizeHtml(html) {
+  if (typeof html !== "string") return "";
+  return import_isomorphic_dompurify.default.sanitize(html, {
+    ALLOWED_TAGS: DEFAULT_ALLOWED_TAGS,
+    ALLOWED_ATTR: DEFAULT_ALLOWED_ATTR,
+    ADD_ATTR: ["target"]
+  });
+}
+
+// src/utils/cn.ts
+function cn(...args) {
+  return args.filter(Boolean).join(" ");
+}
+
+// src/components/Editable.tsx
+var import_jsx_runtime6 = require("react/jsx-runtime");
+function Editable({
+  contentKey,
+  defaultValue,
+  as = "span",
+  multiline = false,
+  className
+}) {
+  const isEditMode = useEditModeMessaging();
+  const sendEditRequest = useSendEditRequest();
+  const { value, isLoading, contentType } = useSiteContentQuery(contentKey, {
+    defaultValue
+  });
+  const section = contentKey.includes(".") ? contentKey.split(".")[0] : void 0;
+  const handleClick = (0, import_react7.useCallback)(
+    (e) => {
+      if (isEditMode) {
+        e.preventDefault();
+        e.stopPropagation();
+        sendEditRequest(
+          contentKey,
+          value,
+          contentType?.toLowerCase() || "text",
+          section
+        );
+      }
+    },
+    [isEditMode, contentKey, value, contentType, section, sendEditRequest]
+  );
+  if (isLoading) {
+    return (0, import_react7.createElement)(as, {
+      className: cn(
+        "animate-pulse bg-muted rounded",
+        multiline ? "h-20" : "h-6",
+        "inline-block min-w-[100px]",
+        className
+      ),
+      "aria-busy": true,
+      "aria-label": "Loading content..."
+    });
+  }
+  const editModeStyles = isEditMode ? cn(
+    "cursor-pointer transition-all duration-200",
+    "hover:ring-2 hover:ring-blue-500 hover:ring-offset-2",
+    "hover:bg-blue-50/50 dark:hover:bg-blue-950/30",
+    "relative group"
+  ) : "";
+  if (multiline && value.includes("\n")) {
+    const safeBr = sanitizeHtml(value.replace(/\n/g, "<br />"));
+    return (0, import_react7.createElement)(as, {
+      className: cn(className, editModeStyles),
+      "data-content-key": contentKey,
+      "data-editable": isEditMode ? "true" : void 0,
+      onClick: isEditMode ? handleClick : void 0,
+      dangerouslySetInnerHTML: { __html: safeBr },
+      title: isEditMode ? "Click to edit" : void 0
+    });
+  }
+  return (0, import_react7.createElement)(
+    as,
+    {
+      className: cn(className, editModeStyles),
+      "data-content-key": contentKey,
+      "data-editable": isEditMode ? "true" : void 0,
+      onClick: isEditMode ? handleClick : void 0,
+      title: isEditMode ? "Click to edit" : void 0
+    },
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)(import_jsx_runtime6.Fragment, { children: [
+      value,
+      isEditMode && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "absolute -top-6 left-1/2 -translate-x-1/2 px-2 py-0.5 bg-blue-600 text-white text-[10px] rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-50", children: "Click to edit" })
+    ] })
+  );
+}
+function EditableHTML({
+  contentKey,
+  defaultValue,
+  as = "div",
+  className
+}) {
+  const isEditMode = useEditModeMessaging();
+  const sendEditRequest = useSendEditRequest();
+  const { value, isLoading } = useSiteContentQuery(contentKey, {
+    defaultValue
+  });
+  const section = contentKey.includes(".") ? contentKey.split(".")[0] : void 0;
+  const handleClick = (0, import_react7.useCallback)(
+    (e) => {
+      if (isEditMode) {
+        e.preventDefault();
+        e.stopPropagation();
+        sendEditRequest(contentKey, value, "html", section);
+      }
+    },
+    [isEditMode, contentKey, value, section, sendEditRequest]
+  );
+  if (isLoading) {
+    return (0, import_react7.createElement)(as, {
+      className: cn("animate-pulse bg-muted rounded h-32", className),
+      "aria-busy": true
+    });
+  }
+  const editModeStyles = isEditMode ? cn(
+    "cursor-pointer transition-all duration-200",
+    "hover:ring-2 hover:ring-blue-500 hover:ring-offset-2",
+    "hover:bg-blue-50/50 dark:hover:bg-blue-950/30",
+    "relative group"
+  ) : "";
+  const safeHtml = sanitizeHtml(value);
+  return (0, import_react7.createElement)(as, {
+    className: cn("prose prose-slate dark:prose-invert", className, editModeStyles),
+    "data-content-key": contentKey,
+    "data-editable": isEditMode ? "true" : void 0,
+    onClick: isEditMode ? handleClick : void 0,
+    title: isEditMode ? "Click to edit" : void 0,
+    dangerouslySetInnerHTML: { __html: safeHtml }
+  });
+}
+function EditableImage({
+  contentKey,
+  defaultValue,
+  alt,
+  className,
+  width,
+  height,
+  priority = false
+}) {
+  const isEditMode = useEditModeMessaging();
+  const sendEditRequest = useSendEditRequest();
+  const { value: src, isLoading } = useSiteContentQuery(contentKey, {
+    defaultValue
+  });
+  const section = contentKey.includes(".") ? contentKey.split(".")[0] : void 0;
+  const handleClick = (0, import_react7.useCallback)(
+    (e) => {
+      if (isEditMode) {
+        e.preventDefault();
+        e.stopPropagation();
+        sendEditRequest(contentKey, src, "image", section);
+      }
+    },
+    [isEditMode, contentKey, src, section, sendEditRequest]
+  );
+  if (isLoading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      "div",
+      {
+        className: cn("animate-pulse bg-muted rounded", className),
+        style: { width, height },
+        "aria-busy": "true"
+      }
+    );
+  }
+  const editModeStyles = isEditMode ? cn(
+    "cursor-pointer transition-all duration-200",
+    "hover:ring-2 hover:ring-blue-500 hover:ring-offset-2",
+    "hover:opacity-90",
+    "relative group"
+  ) : "";
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsxs)("div", { className: cn("relative", isEditMode && "group"), children: [
+    /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
+      "img",
+      {
+        src,
+        alt,
+        className: cn(className, editModeStyles),
+        width,
+        height,
+        loading: priority ? "eager" : "lazy",
+        "data-content-key": contentKey,
+        "data-editable": isEditMode ? "true" : void 0,
+        onClick: isEditMode ? handleClick : void 0,
+        title: isEditMode ? "Click to edit image" : void 0
+      }
+    ),
+    isEditMode && /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("span", { className: "absolute top-2 left-2 px-2 py-0.5 bg-blue-600 text-white text-[10px] rounded opacity-0 group-hover:opacity-100 transition-opacity pointer-events-none", children: "Click to edit image" })
+  ] });
+}
+
+// src/hooks/useServices.ts
+var import_react8 = require("react");
 function useServices(options = {}) {
   const { client } = useFoxPixelContext();
-  const [services, setServices] = (0, import_react6.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(true);
-  const [error, setError] = (0, import_react6.useState)(null);
+  const [services, setServices] = (0, import_react8.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(true);
+  const [error, setError] = (0, import_react8.useState)(null);
   const fetchServices = async () => {
     try {
       setIsLoading(true);
@@ -414,7 +765,7 @@ function useServices(options = {}) {
       setIsLoading(false);
     }
   };
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     fetchServices();
   }, [options.category, options.active]);
   return {
@@ -426,11 +777,11 @@ function useServices(options = {}) {
 }
 
 // src/hooks/useLeadCapture.ts
-var import_react7 = require("react");
+var import_react9 = require("react");
 function useLeadCapture() {
   const { client } = useFoxPixelContext();
-  const [isLoading, setIsLoading] = (0, import_react7.useState)(false);
-  const [error, setError] = (0, import_react7.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react9.useState)(false);
+  const [error, setError] = (0, import_react9.useState)(null);
   const captureLead = async (data) => {
     try {
       setIsLoading(true);
@@ -453,11 +804,11 @@ function useLeadCapture() {
 }
 
 // src/hooks/useContactCapture.ts
-var import_react8 = require("react");
+var import_react10 = require("react");
 function useContactCapture() {
   const { client } = useFoxPixelContext();
-  const [isLoading, setIsLoading] = (0, import_react8.useState)(false);
-  const [error, setError] = (0, import_react8.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react10.useState)(false);
+  const [error, setError] = (0, import_react10.useState)(null);
   const captureContact = async (data) => {
     try {
       setIsLoading(true);
@@ -478,18 +829,883 @@ function useContactCapture() {
     error
   };
 }
+
+// src/hooks/useSiteContent.ts
+var import_react11 = require("react");
+function useSiteContent(contentKey, options = {}) {
+  const { defaultValue = "", fetchOnMount = true } = options;
+  const { client } = useFoxPixelContext();
+  const { user, hasPermission } = useAuth();
+  const [data, setData] = (0, import_react11.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react11.useState)(fetchOnMount);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const canEdit = user !== null && hasPermission("site:content:update");
+  const fetchContent = (0, import_react11.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const content = await client.get(
+        `/api/site/content/${encodeURIComponent(contentKey)}`
+      );
+      setData(content);
+    } catch (err) {
+      if (err?.status === 404) {
+        setData(null);
+      } else {
+        setError(err);
+      }
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, contentKey]);
+  const updateContent = (0, import_react11.useCallback)(async (newValue) => {
+    try {
+      setError(null);
+      const updated = await client.put(
+        `/api/site/content/${encodeURIComponent(contentKey)}`,
+        { value: newValue }
+      );
+      setData(updated);
+    } catch (err) {
+      setError(err);
+      throw err;
+    }
+  }, [client, contentKey]);
+  (0, import_react11.useEffect)(() => {
+    if (fetchOnMount) {
+      fetchContent();
+    }
+  }, [contentKey, fetchOnMount]);
+  const value = data?.value ?? defaultValue;
+  return {
+    data,
+    value,
+    isLoading,
+    error,
+    canEdit,
+    update: updateContent,
+    refetch: fetchContent
+  };
+}
+function useSiteContents(contentKeys, options = {}) {
+  const { defaults = {} } = options;
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react11.useState)({});
+  const [isLoading, setIsLoading] = (0, import_react11.useState)(true);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const fetchContents = (0, import_react11.useCallback)(async () => {
+    if (contentKeys.length === 0) {
+      setData({});
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const contents = await client.post(
+        "/api/site/content/batch",
+        contentKeys
+      );
+      setData(contents);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, contentKeys.join(",")]);
+  (0, import_react11.useEffect)(() => {
+    fetchContents();
+  }, [fetchContents]);
+  const getValue = (0, import_react11.useCallback)((key, defaultValue) => {
+    const content = data[key];
+    if (content?.value) {
+      return content.value;
+    }
+    return defaultValue ?? defaults[key] ?? "";
+  }, [data, defaults]);
+  return {
+    data,
+    getValue,
+    isLoading,
+    error,
+    refetch: fetchContents
+  };
+}
+function useSiteContentSection(section) {
+  const { client } = useFoxPixelContext();
+  const [contents, setContents] = (0, import_react11.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react11.useState)(true);
+  const [error, setError] = (0, import_react11.useState)(null);
+  const fetchContents = (0, import_react11.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const data = await client.get(
+        `/api/site/content/section/${encodeURIComponent(section)}`
+      );
+      setContents(data);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, section]);
+  (0, import_react11.useEffect)(() => {
+    fetchContents();
+  }, [fetchContents]);
+  return {
+    contents,
+    isLoading,
+    error,
+    refetch: fetchContents
+  };
+}
+
+// src/blog/hooks.ts
+var import_react12 = require("react");
+function useBlogPosts(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const page = options.page ?? 0;
+  const limit = options.limit ?? 10;
+  const fetchPosts = async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const params = new URLSearchParams();
+      params.append("page", String(page));
+      params.append("size", String(limit));
+      const url = `/api/v1/blog/posts?${params.toString()}`;
+      const result = await client.get(url);
+      setData(result);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchPosts();
+  }, [page, limit]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchPosts
+  };
+}
+function useBlogPost(slug) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(!!slug);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchPost = async () => {
+    if (!slug) {
+      setData(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get(`/api/v1/blog/posts/${encodeURIComponent(slug)}`);
+      setData(result);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchPost();
+  }, [slug]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchPost
+  };
+}
+function useBlogCategories() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchCategories = async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/v1/blog/categories");
+      setData(Array.isArray(result) ? result : []);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchCategories();
+  }, []);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchCategories
+  };
+}
+function useBlogTags() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchTags = async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/v1/blog/tags");
+      setData(Array.isArray(result) ? result : []);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchTags();
+  }, []);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchTags
+  };
+}
+function useBlogComments(slug) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(!!slug);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchComments = async () => {
+    if (!slug) {
+      setData(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get(
+        `/api/v1/blog/posts/${encodeURIComponent(slug)}/comments`
+      );
+      setData(Array.isArray(result) ? result : []);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchComments();
+  }, [slug]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchComments
+  };
+}
+function useBlogCommentSubmit(slug) {
+  const { client } = useFoxPixelContext();
+  const [isSubmitting, setIsSubmitting] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const submit = async (payload) => {
+    if (!slug) return null;
+    try {
+      setIsSubmitting(true);
+      setError(null);
+      const result = await client.post(
+        `/api/v1/blog/posts/${encodeURIComponent(slug)}/comments`,
+        payload
+      );
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const resetError = () => setError(null);
+  return {
+    submit,
+    isSubmitting,
+    error,
+    resetError
+  };
+}
+function useBlogFeaturedPosts(limit = 6) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react12.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react12.useState)(true);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const fetchFeatured = async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const params = new URLSearchParams();
+      params.append("page", "0");
+      params.append("size", String(limit));
+      const url = `/api/v1/blog/posts/featured?${params.toString()}`;
+      const result = await client.get(url);
+      setData(result);
+    } catch (err) {
+      setError(err);
+      setData(null);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  (0, import_react12.useEffect)(() => {
+    fetchFeatured();
+  }, [limit]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchFeatured
+  };
+}
+function useNewsletterSubscribe() {
+  const { client } = useFoxPixelContext();
+  const [isSubmitting, setIsSubmitting] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const [success, setSuccess] = (0, import_react12.useState)(false);
+  const subscribe = async (payload) => {
+    try {
+      setIsSubmitting(true);
+      setError(null);
+      setSuccess(false);
+      const result = await client.post(
+        "/api/v1/blog/newsletter/subscribe",
+        payload
+      );
+      setSuccess(true);
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const reset = () => {
+    setError(null);
+    setSuccess(false);
+  };
+  return {
+    subscribe,
+    isSubmitting,
+    error,
+    success,
+    reset
+  };
+}
+function useNewsletterUnsubscribe() {
+  const { client } = useFoxPixelContext();
+  const [isSubmitting, setIsSubmitting] = (0, import_react12.useState)(false);
+  const [error, setError] = (0, import_react12.useState)(null);
+  const [success, setSuccess] = (0, import_react12.useState)(false);
+  const unsubscribe = async (email) => {
+    try {
+      setIsSubmitting(true);
+      setError(null);
+      setSuccess(false);
+      await client.post("/api/v1/blog/newsletter/unsubscribe", null, {
+        params: { email }
+      });
+      setSuccess(true);
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  const unsubscribeByToken = async (token) => {
+    try {
+      setIsSubmitting(true);
+      setError(null);
+      setSuccess(false);
+      await client.get("/api/v1/blog/newsletter/unsubscribe", {
+        params: { token }
+      });
+      setSuccess(true);
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+  return {
+    unsubscribe,
+    unsubscribeByToken,
+    isSubmitting,
+    error,
+    success
+  };
+}
+
+// src/blog/admin-hooks.ts
+var import_react13 = require("react");
+function useAdminBlogPosts(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const page = options.page ?? 0;
+  const size = options.size ?? 20;
+  const fetchPosts = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const params = new URLSearchParams();
+      params.append("page", String(page));
+      params.append("size", String(size));
+      const result = await client.get(`/api/blog/posts?${params.toString()}`);
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, page, size]);
+  (0, import_react13.useEffect)(() => {
+    fetchPosts();
+  }, [fetchPosts]);
+  return { data, isLoading, error, refetch: fetchPosts };
+}
+function useAdminBlogPost(id) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(!!id);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchPost = (0, import_react13.useCallback)(async () => {
+    if (!id) {
+      setData(null);
+      setIsLoading(false);
+      return;
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get(`/api/blog/posts/${id}`);
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, id]);
+  (0, import_react13.useEffect)(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return { data, isLoading, error, refetch: fetchPost };
+}
+function useAdminBlogPostMutations() {
+  const { client } = useFoxPixelContext();
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(false);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const create = async (payload) => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.post("/api/blog/posts", payload);
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const update = async (id, payload) => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.put(`/api/blog/posts/${id}`, payload);
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  const remove = async (id) => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      await client.delete(`/api/blog/posts/${id}`);
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return { create, update, remove, isLoading, error };
+}
+function useAdminBlogCategories() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchCategories = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/categories");
+      setData(Array.isArray(result) ? result : []);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchCategories();
+  }, [fetchCategories]);
+  const create = async (payload) => {
+    try {
+      const result = await client.post("/api/blog/categories", payload);
+      await fetchCategories();
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    }
+  };
+  const update = async (id, payload) => {
+    try {
+      const result = await client.put(`/api/blog/categories/${id}`, payload);
+      await fetchCategories();
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    }
+  };
+  const remove = async (id) => {
+    try {
+      await client.delete(`/api/blog/categories/${id}`);
+      await fetchCategories();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    }
+  };
+  return { data, isLoading, error, refetch: fetchCategories, create, update, remove };
+}
+function useAdminBlogTags() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchTags = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/tags");
+      setData(Array.isArray(result) ? result : []);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchTags();
+  }, [fetchTags]);
+  const create = async (payload) => {
+    try {
+      const result = await client.post("/api/blog/tags", payload);
+      await fetchTags();
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    }
+  };
+  const update = async (id, payload) => {
+    try {
+      const result = await client.put(`/api/blog/tags/${id}`, payload);
+      await fetchTags();
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    }
+  };
+  const remove = async (id) => {
+    try {
+      await client.delete(`/api/blog/tags/${id}`);
+      await fetchTags();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    }
+  };
+  return { data, isLoading, error, refetch: fetchTags, create, update, remove };
+}
+function useAdminBlogComments(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const { status, postId, page = 0, size = 20 } = options;
+  const fetchComments = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const params = new URLSearchParams();
+      params.append("page", String(page));
+      params.append("size", String(size));
+      if (status) params.append("status", status);
+      if (postId) params.append("postId", postId);
+      const result = await client.get(`/api/blog/comments?${params.toString()}`);
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, status, postId, page, size]);
+  (0, import_react13.useEffect)(() => {
+    fetchComments();
+  }, [fetchComments]);
+  const updateStatus = async (id, newStatus) => {
+    try {
+      await client.put(`/api/blog/comments/${id}/status`, { status: newStatus });
+      await fetchComments();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    }
+  };
+  const remove = async (id) => {
+    try {
+      await client.delete(`/api/blog/comments/${id}`);
+      await fetchComments();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    }
+  };
+  return { data, isLoading, error, refetch: fetchComments, updateStatus, remove };
+}
+function useAdminNewsletterSubscribers(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const { status, page = 0, size = 20 } = options;
+  const fetchSubscribers = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const params = new URLSearchParams();
+      params.append("page", String(page));
+      params.append("size", String(size));
+      if (status) params.append("status", status);
+      const result = await client.get(`/api/blog/newsletter/subscribers?${params.toString()}`);
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, status, page, size]);
+  (0, import_react13.useEffect)(() => {
+    fetchSubscribers();
+  }, [fetchSubscribers]);
+  const remove = async (id) => {
+    try {
+      await client.delete(`/api/blog/newsletter/subscribers/${id}`);
+      await fetchSubscribers();
+      return true;
+    } catch (err) {
+      setError(err);
+      return false;
+    }
+  };
+  return { data, isLoading, error, refetch: fetchSubscribers, remove };
+}
+function useAdminNewsletterStats() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchStats = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/newsletter/stats");
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchStats();
+  }, [fetchStats]);
+  return { data, isLoading, error, refetch: fetchStats };
+}
+function useAdminBlogSettings() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchSettings = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/settings");
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchSettings();
+  }, [fetchSettings]);
+  const update = async (settings) => {
+    try {
+      const result = await client.put("/api/blog/settings", settings);
+      setData(result);
+      return result;
+    } catch (err) {
+      setError(err);
+      return null;
+    }
+  };
+  return { data, isLoading, error, refetch: fetchSettings, update };
+}
+function useAdminBlogAnalytics() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = (0, import_react13.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react13.useState)(true);
+  const [error, setError] = (0, import_react13.useState)(null);
+  const fetchAnalytics = (0, import_react13.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/analytics/summary");
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  (0, import_react13.useEffect)(() => {
+    fetchAnalytics();
+  }, [fetchAnalytics]);
+  return { data, isLoading, error, refetch: fetchAnalytics };
+}
+
+// src/blog/utils.ts
+function getBlogPostSchemaLd(post, options) {
+  const { siteUrl, publisherName, publisherLogoUrl } = options;
+  const postUrl = `${siteUrl.replace(/\/$/, "")}/blog/${post.slug}`;
+  const schema = {
+    "@context": "https://schema.org",
+    "@type": "BlogPosting",
+    headline: post.title,
+    description: post.metaDescription || post.excerpt || void 0,
+    image: post.coverImageUrl || void 0,
+    datePublished: post.publishedAt || void 0,
+    dateModified: post.updatedAt,
+    mainEntityOfPage: {
+      "@type": "WebPage",
+      "@id": postUrl
+    }
+  };
+  if (publisherName || publisherLogoUrl) {
+    schema.publisher = {
+      "@type": "Organization",
+      ...publisherName && { name: publisherName },
+      ...publisherLogoUrl && {
+        logo: {
+          "@type": "ImageObject",
+          url: publisherLogoUrl
+        }
+      }
+    };
+  }
+  return schema;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthProvider,
+  Editable,
+  EditableHTML,
+  EditableImage,
   FoxPixelHttpClient,
   FoxPixelProvider,
   GuestOnlyRoute,
   ProtectedRoute,
+  SITE_CONTENT_QUERY_KEY,
+  getBlogPostSchemaLd,
+  useAdminBlogAnalytics,
+  useAdminBlogCategories,
+  useAdminBlogComments,
+  useAdminBlogPost,
+  useAdminBlogPostMutations,
+  useAdminBlogPosts,
+  useAdminBlogSettings,
+  useAdminBlogTags,
+  useAdminNewsletterStats,
+  useAdminNewsletterSubscribers,
   useAuth,
+  useBlogCategories,
+  useBlogCommentSubmit,
+  useBlogComments,
+  useBlogFeaturedPosts,
+  useBlogPost,
+  useBlogPosts,
+  useBlogTags,
   useContactCapture,
+  useEditMode,
+  useEditModeMessaging,
   useFoxPixelContext,
   useLeadCapture,
+  useNewsletterSubscribe,
+  useNewsletterUnsubscribe,
+  useSendEditRequest,
   useServices,
+  useSiteContent,
+  useSiteContentQuery,
+  useSiteContentSection,
+  useSiteContents,
   withAuth
 });
 //# sourceMappingURL=index.js.map