@foxpixel/react 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -432,16 +432,721 @@ function useContactCapture() {
     error
   };
 }
+
+// src/blog/hooks.ts
+import { useState as useState8, useEffect as useEffect6 } from "react";
+function useBlogPosts(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchPosts();
+  }, [page, limit]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchPosts
+  };
+}
+function useBlogPost(slug) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(!!slug);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchPost();
+  }, [slug]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchPost
+  };
+}
+function useBlogCategories() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchCategories();
+  }, []);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchCategories
+  };
+}
+function useBlogTags() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchTags();
+  }, []);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchTags
+  };
+}
+function useBlogComments(slug) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(!!slug);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchComments();
+  }, [slug]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchComments
+  };
+}
+function useBlogCommentSubmit(slug) {
+  const { client } = useFoxPixelContext();
+  const [isSubmitting, setIsSubmitting] = useState8(false);
+  const [error, setError] = useState8(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] = useState8(null);
+  const [isLoading, setIsLoading] = useState8(true);
+  const [error, setError] = useState8(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);
+    }
+  };
+  useEffect6(() => {
+    fetchFeatured();
+  }, [limit]);
+  return {
+    data,
+    isLoading,
+    error,
+    refetch: fetchFeatured
+  };
+}
+function useNewsletterSubscribe() {
+  const { client } = useFoxPixelContext();
+  const [isSubmitting, setIsSubmitting] = useState8(false);
+  const [error, setError] = useState8(null);
+  const [success, setSuccess] = useState8(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] = useState8(false);
+  const [error, setError] = useState8(null);
+  const [success, setSuccess] = useState8(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);
+    }
+  };
+  return {
+    unsubscribe,
+    isSubmitting,
+    error,
+    success
+  };
+}
+
+// src/blog/admin-hooks.ts
+import { useState as useState9, useEffect as useEffect7, useCallback as useCallback2 } from "react";
+function useAdminBlogPosts(options = {}) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const page = options.page ?? 0;
+  const size = options.size ?? 20;
+  const fetchPosts = useCallback2(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]);
+  useEffect7(() => {
+    fetchPosts();
+  }, [fetchPosts]);
+  return { data, isLoading, error, refetch: fetchPosts };
+}
+function useAdminBlogPost(id) {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(!!id);
+  const [error, setError] = useState9(null);
+  const fetchPost = useCallback2(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]);
+  useEffect7(() => {
+    fetchPost();
+  }, [fetchPost]);
+  return { data, isLoading, error, refetch: fetchPost };
+}
+function useAdminBlogPostMutations() {
+  const { client } = useFoxPixelContext();
+  const [isLoading, setIsLoading] = useState9(false);
+  const [error, setError] = useState9(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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchCategories = useCallback2(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]);
+  useEffect7(() => {
+    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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchTags = useCallback2(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]);
+  useEffect7(() => {
+    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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const { status, postId, page = 0, size = 20 } = options;
+  const fetchComments = useCallback2(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]);
+  useEffect7(() => {
+    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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const { status, page = 0, size = 20 } = options;
+  const fetchSubscribers = useCallback2(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]);
+  useEffect7(() => {
+    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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchStats = useCallback2(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]);
+  useEffect7(() => {
+    fetchStats();
+  }, [fetchStats]);
+  return { data, isLoading, error, refetch: fetchStats };
+}
+function useAdminBlogSettings() {
+  const { client } = useFoxPixelContext();
+  const [data, setData] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchSettings = useCallback2(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const result = await client.get("/api/blog/settings");
+      setData(result);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  useEffect7(() => {
+    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] = useState9(null);
+  const [isLoading, setIsLoading] = useState9(true);
+  const [error, setError] = useState9(null);
+  const fetchAnalytics = useCallback2(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]);
+  useEffect7(() => {
+    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;
+}
 export {
   AuthProvider,
   FoxPixelHttpClient,
   FoxPixelProvider,
   GuestOnlyRoute,
   ProtectedRoute,
+  getBlogPostSchemaLd,
+  useAdminBlogAnalytics,
+  useAdminBlogCategories,
+  useAdminBlogComments,
+  useAdminBlogPost,
+  useAdminBlogPostMutations,
+  useAdminBlogPosts,
+  useAdminBlogSettings,
+  useAdminBlogTags,
+  useAdminNewsletterStats,
+  useAdminNewsletterSubscribers,
   useAuth,
+  useBlogCategories,
+  useBlogCommentSubmit,
+  useBlogComments,
+  useBlogFeaturedPosts,
+  useBlogPost,
+  useBlogPosts,
+  useBlogTags,
   useContactCapture,
   useFoxPixelContext,
   useLeadCapture,
+  useNewsletterSubscribe,
+  useNewsletterUnsubscribe,
   useServices,
   withAuth
 };