@appgram/react 0.1.0

package/dist/chunk-75P634IK.js

@@ -0,0 +1,758 @@
+'use strict';
+
+var react = require('react');
+var clsx = require('clsx');
+var tailwindMerge = require('tailwind-merge');
+
+// src/provider/context.ts
+var AppgramContext = react.createContext(null);
+function useAppgramContext() {
+  const context = react.useContext(AppgramContext);
+  if (!context) {
+    throw new Error(
+      "useAppgramContext must be used within an AppgramProvider. Make sure you have wrapped your app with <AppgramProvider>."
+    );
+  }
+  return context;
+}
+
+// src/utils/fingerprint.ts
+var STORAGE_KEY = "appgram_fingerprint";
+function simpleHash(str) {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function getBrowserCharacteristics() {
+  if (typeof window === "undefined") {
+    return "server-side";
+  }
+  const characteristics = [
+    navigator.userAgent,
+    navigator.language,
+    screen.colorDepth,
+    screen.width,
+    screen.height,
+    (/* @__PURE__ */ new Date()).getTimezoneOffset(),
+    navigator.hardwareConcurrency || 0,
+    "deviceMemory" in navigator ? navigator.deviceMemory : 0
+  ];
+  return characteristics.join("|");
+}
+function generateFingerprint() {
+  const characteristics = getBrowserCharacteristics();
+  const timestamp = Date.now().toString(36);
+  const randomBytes = new Uint8Array(6);
+  crypto.getRandomValues(randomBytes);
+  const random = Array.from(randomBytes, (b) => b.toString(36)).join("").substring(0, 10);
+  return `${simpleHash(characteristics)}-${timestamp}-${random}`;
+}
+function getFingerprint() {
+  if (typeof window === "undefined") {
+    return "server-side-fingerprint";
+  }
+  let fingerprint = localStorage.getItem(STORAGE_KEY);
+  if (!fingerprint) {
+    fingerprint = generateFingerprint();
+    try {
+      localStorage.setItem(STORAGE_KEY, fingerprint);
+    } catch {
+    }
+  }
+  return fingerprint;
+}
+function resetFingerprint() {
+  if (typeof window === "undefined") return;
+  try {
+    localStorage.removeItem(STORAGE_KEY);
+  } catch {
+  }
+}
+function cn(...inputs) {
+  return tailwindMerge.twMerge(clsx.clsx(inputs));
+}
+
+// src/utils/index.ts
+function getErrorMessage(error, fallback = "An error occurred") {
+  if (!error) return fallback;
+  if (typeof error === "string") return error;
+  if (typeof error === "object" && error !== null) {
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+  }
+  return fallback;
+}
+function useWishes(options = {}) {
+  const { client, fingerprint } = useAppgramContext();
+  const [wishes, setWishes] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const [total, setTotal] = react.useState(0);
+  const [page, setPage] = react.useState(options.filters?.page || 1);
+  const [totalPages, setTotalPages] = react.useState(0);
+  const [filters, setFilters] = react.useState(options.filters || {});
+  const intervalRef = react.useRef(null);
+  const fetchWishes = react.useCallback(async () => {
+    if (options.skip) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getPublicWishes({
+        ...filters,
+        page,
+        fingerprint: fingerprint ?? void 0
+      });
+      if (response.success && response.data) {
+        const wishData = response.data.data || [];
+        setWishes(wishData);
+        setTotal(response.data.total);
+        setTotalPages(response.data.total_pages);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch wishes"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, fingerprint, filters, page, options.skip]);
+  react.useEffect(() => {
+    fetchWishes();
+  }, [fetchWishes]);
+  react.useEffect(() => {
+    if (options.refreshInterval && options.refreshInterval > 0) {
+      intervalRef.current = setInterval(fetchWishes, options.refreshInterval);
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+      }
+    };
+  }, [options.refreshInterval, fetchWishes]);
+  const handleSetFilters = react.useCallback((newFilters) => {
+    setFilters(newFilters);
+    setPage(1);
+  }, []);
+  return {
+    wishes,
+    isLoading,
+    error,
+    total,
+    page,
+    totalPages,
+    setFilters: handleSetFilters,
+    setPage,
+    refetch: fetchWishes
+  };
+}
+function useVote(options) {
+  const { client, fingerprint } = useAppgramContext();
+  const [hasVoted, setHasVoted] = react.useState(options.initialHasVoted || false);
+  const [voteCount, setVoteCount] = react.useState(options.initialVoteCount || 0);
+  const [voteId, setVoteId] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [isChecking, setIsChecking] = react.useState(false);
+  const [hasChecked, setHasChecked] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const skipAutoCheck = options.skipAutoCheck !== false;
+  const checkVoteStatus = react.useCallback(async () => {
+    if (!fingerprint || !options.wishId || hasChecked) {
+      return;
+    }
+    setIsChecking(true);
+    try {
+      const response = await client.checkVote(options.wishId, fingerprint);
+      if (response.success && response.data) {
+        setHasVoted(response.data.has_voted);
+        if (response.data.vote_id) {
+          setVoteId(response.data.vote_id);
+        }
+      }
+      setHasChecked(true);
+    } catch {
+      setHasChecked(true);
+    } finally {
+      setIsChecking(false);
+    }
+  }, [client, fingerprint, options.wishId, hasChecked]);
+  react.useEffect(() => {
+    if (!skipAutoCheck) {
+      checkVoteStatus();
+    }
+  }, [skipAutoCheck, checkVoteStatus]);
+  react.useEffect(() => {
+    if (options.initialVoteCount !== void 0) {
+      setVoteCount(options.initialVoteCount);
+    }
+  }, [options.initialVoteCount]);
+  react.useEffect(() => {
+    if (options.initialHasVoted !== void 0) {
+      setHasVoted(options.initialHasVoted);
+    }
+  }, [options.initialHasVoted]);
+  const vote = react.useCallback(async () => {
+    if (!fingerprint || isLoading) return;
+    if (!hasChecked) {
+      setIsLoading(true);
+      try {
+        const checkResponse = await client.checkVote(options.wishId, fingerprint);
+        if (checkResponse.success && checkResponse.data) {
+          setHasVoted(checkResponse.data.has_voted);
+          if (checkResponse.data.vote_id) {
+            setVoteId(checkResponse.data.vote_id);
+          }
+          setHasChecked(true);
+          if (checkResponse.data.has_voted) {
+            setIsLoading(false);
+            return;
+          }
+        }
+      } catch {
+        setHasChecked(true);
+      }
+    } else if (hasVoted) {
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.createVote(
+        options.wishId,
+        fingerprint,
+        options.voterEmail
+      );
+      if (response.success && response.data) {
+        setHasVoted(true);
+        setVoteId(response.data.id);
+        setVoteCount((prev) => prev + 1);
+        options.onVoteChange?.(true, voteCount + 1);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to vote"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "Failed to vote"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, fingerprint, hasVoted, hasChecked, isLoading, options, voteCount]);
+  const unvote = react.useCallback(async () => {
+    if (!voteId || !hasVoted || isLoading) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.deleteVote(voteId);
+      if (response.success) {
+        setHasVoted(false);
+        setVoteId(null);
+        setVoteCount((prev) => Math.max(0, prev - 1));
+        options.onVoteChange?.(false, Math.max(0, voteCount - 1));
+      } else {
+        setError(getErrorMessage(response.error, "Failed to remove vote"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "Failed to remove vote"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, hasVoted, isLoading, options, voteCount, voteId]);
+  const toggle = react.useCallback(async () => {
+    if (!fingerprint || isLoading) return;
+    if (!hasChecked) {
+      setIsLoading(true);
+      try {
+        const checkResponse = await client.checkVote(options.wishId, fingerprint);
+        if (checkResponse.success && checkResponse.data) {
+          const alreadyVoted = checkResponse.data.has_voted;
+          setHasVoted(alreadyVoted);
+          if (checkResponse.data.vote_id) {
+            setVoteId(checkResponse.data.vote_id);
+          }
+          setHasChecked(true);
+          setIsLoading(false);
+          if (alreadyVoted) {
+            if (checkResponse.data.vote_id) {
+              await unvote();
+            }
+          } else {
+            await vote();
+          }
+          return;
+        }
+      } catch {
+        setHasChecked(true);
+        setIsLoading(false);
+      }
+    }
+    if (hasVoted) {
+      await unvote();
+    } else {
+      await vote();
+    }
+  }, [client, fingerprint, hasVoted, hasChecked, isLoading, options.wishId, unvote, vote]);
+  return {
+    hasVoted,
+    voteCount,
+    isLoading,
+    isChecking,
+    error,
+    toggle,
+    vote,
+    unvote
+  };
+}
+function useComments(options) {
+  const { client } = useAppgramContext();
+  const [comments, setComments] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [isCreating, setIsCreating] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [total, setTotal] = react.useState(0);
+  const [page, setPage] = react.useState(1);
+  const [totalPages, setTotalPages] = react.useState(0);
+  const perPage = options.perPage || 20;
+  const fetchComments = react.useCallback(async () => {
+    if (options.skip || !options.wishId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getComments(options.wishId, {
+        page,
+        per_page: perPage
+      });
+      if (response.success && response.data) {
+        setComments(response.data.data || []);
+        setTotal(response.data.total);
+        setTotalPages(response.data.total_pages);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch comments"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.wishId, options.skip, page, perPage]);
+  react.useEffect(() => {
+    fetchComments();
+  }, [fetchComments]);
+  const createComment = react.useCallback(
+    async (data) => {
+      setIsCreating(true);
+      setError(null);
+      try {
+        const response = await client.createComment({
+          ...data,
+          wish_id: options.wishId
+        });
+        if (response.success && response.data) {
+          setComments((prev) => [response.data, ...prev]);
+          setTotal((prev) => prev + 1);
+          return response.data;
+        } else {
+          setError(getErrorMessage(response.error, "Failed to create comment"));
+          return null;
+        }
+      } catch (err) {
+        setError(getErrorMessage(err, "An error occurred"));
+        return null;
+      } finally {
+        setIsCreating(false);
+      }
+    },
+    [client, options.wishId]
+  );
+  const nextPage = react.useCallback(() => {
+    if (page < totalPages) {
+      setPage((prev) => prev + 1);
+    }
+  }, [page, totalPages]);
+  const prevPage = react.useCallback(() => {
+    if (page > 1) {
+      setPage((prev) => prev - 1);
+    }
+  }, [page]);
+  return {
+    comments,
+    isLoading,
+    isCreating,
+    error,
+    total,
+    page,
+    totalPages,
+    nextPage,
+    prevPage,
+    setPage,
+    createComment,
+    refetch: fetchComments
+  };
+}
+function useRoadmap(options = {}) {
+  const { client } = useAppgramContext();
+  const [roadmap, setRoadmap] = react.useState(null);
+  const [columns, setColumns] = react.useState([]);
+  const [totalItems, setTotalItems] = react.useState(0);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchRoadmap = react.useCallback(async () => {
+    if (options.skip) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getRoadmapData();
+      if (response.success && response.data) {
+        setRoadmap(response.data.roadmap);
+        const cols = response.data.columns || response.data.roadmap?.columns || [];
+        setColumns(cols);
+        const itemCount = response.data.total_items || cols.reduce((sum, col) => sum + (col.items?.length || 0), 0);
+        setTotalItems(itemCount);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch roadmap"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip]);
+  react.useEffect(() => {
+    fetchRoadmap();
+  }, [fetchRoadmap]);
+  react.useEffect(() => {
+    if (!options.refreshInterval || options.refreshInterval <= 0) return;
+    const interval = setInterval(fetchRoadmap, options.refreshInterval);
+    return () => clearInterval(interval);
+  }, [options.refreshInterval, fetchRoadmap]);
+  return {
+    roadmap,
+    columns,
+    totalItems,
+    isLoading,
+    error,
+    refetch: fetchRoadmap
+  };
+}
+function useReleases(options = {}) {
+  const { client } = useAppgramContext();
+  const [releases, setReleases] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchReleases = react.useCallback(async () => {
+    if (options.skip) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getReleases({
+        limit: options.limit || 50
+      });
+      if (response.success && response.data) {
+        setReleases(response.data);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch releases"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip, options.limit]);
+  react.useEffect(() => {
+    fetchReleases();
+  }, [fetchReleases]);
+  return {
+    releases,
+    isLoading,
+    error,
+    refetch: fetchReleases
+  };
+}
+function useRelease(options) {
+  const { client } = useAppgramContext();
+  const [release, setRelease] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchRelease = react.useCallback(async () => {
+    if (options.skip || !options.releaseSlug) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getRelease(options.releaseSlug);
+      if (response.success && response.data) {
+        setRelease(response.data);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch release"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip, options.releaseSlug]);
+  react.useEffect(() => {
+    fetchRelease();
+  }, [fetchRelease]);
+  return {
+    release,
+    isLoading,
+    error,
+    refetch: fetchRelease
+  };
+}
+function useHelpCenter(options = {}) {
+  const { client } = useAppgramContext();
+  const [collection, setCollection] = react.useState(null);
+  const [flows, setFlows] = react.useState([]);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchHelpCenter = react.useCallback(async () => {
+    if (options.skip) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getHelpCollection();
+      if (response.success && response.data) {
+        setCollection(response.data.collection);
+        setFlows(response.data.flows || []);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch help center"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip]);
+  react.useEffect(() => {
+    fetchHelpCenter();
+  }, [fetchHelpCenter]);
+  return {
+    collection,
+    flows,
+    isLoading,
+    error,
+    refetch: fetchHelpCenter
+  };
+}
+function useHelpFlow(options) {
+  const { client } = useAppgramContext();
+  const [flow, setFlow] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchFlow = react.useCallback(async () => {
+    if (options.skip || !options.flowSlug) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getHelpFlow(options.flowSlug);
+      if (response.success && response.data) {
+        setFlow(response.data);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch flow"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip, options.flowSlug]);
+  react.useEffect(() => {
+    fetchFlow();
+  }, [fetchFlow]);
+  return {
+    flow,
+    isLoading,
+    error,
+    refetch: fetchFlow
+  };
+}
+function useHelpArticle(options) {
+  const { client } = useAppgramContext();
+  const [article, setArticle] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(!options.skip);
+  const [error, setError] = react.useState(null);
+  const fetchArticle = react.useCallback(async () => {
+    if (options.skip || !options.articleSlug || !options.flowId) return;
+    setIsLoading(true);
+    setError(null);
+    try {
+      const response = await client.getHelpArticle(options.articleSlug, options.flowId);
+      if (response.success && response.data) {
+        setArticle(response.data);
+      } else {
+        setError(getErrorMessage(response.error, "Failed to fetch article"));
+      }
+    } catch (err) {
+      setError(getErrorMessage(err, "An error occurred"));
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, options.skip, options.articleSlug, options.flowId]);
+  react.useEffect(() => {
+    fetchArticle();
+  }, [fetchArticle]);
+  return {
+    article,
+    isLoading,
+    error,
+    refetch: fetchArticle
+  };
+}
+function useSupport(options = {}) {
+  const { client } = useAppgramContext();
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  const [isSendingMagicLink, setIsSendingMagicLink] = react.useState(false);
+  const [isVerifying, setIsVerifying] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [successMessage, setSuccessMessage] = react.useState(null);
+  const clearMessages = react.useCallback(() => {
+    setError(null);
+    setSuccessMessage(null);
+  }, []);
+  const submitTicket = react.useCallback(
+    async (data) => {
+      setIsSubmitting(true);
+      setError(null);
+      setSuccessMessage(null);
+      try {
+        const response = await client.submitSupportRequest(data);
+        if (response.success && response.data) {
+          setSuccessMessage("Your support request has been submitted successfully.");
+          options.onSubmitSuccess?.(response.data);
+          return response.data;
+        } else {
+          const errorMsg = getErrorMessage(response.error, "Failed to submit support request");
+          setError(errorMsg);
+          options.onSubmitError?.(errorMsg);
+          return null;
+        }
+      } catch (err) {
+        const errorMsg = getErrorMessage(err, "An error occurred");
+        setError(errorMsg);
+        options.onSubmitError?.(errorMsg);
+        return null;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [client, options]
+  );
+  const requestMagicLink = react.useCallback(
+    async (email) => {
+      setIsSendingMagicLink(true);
+      setError(null);
+      setSuccessMessage(null);
+      try {
+        const response = await client.sendSupportMagicLink(email);
+        if (response.success) {
+          setSuccessMessage("A magic link has been sent to your email.");
+          return true;
+        } else {
+          setError(getErrorMessage(response.error, "Failed to send magic link"));
+          return false;
+        }
+      } catch (err) {
+        setError(getErrorMessage(err, "An error occurred"));
+        return false;
+      } finally {
+        setIsSendingMagicLink(false);
+      }
+    },
+    [client]
+  );
+  const verifyToken = react.useCallback(
+    async (token) => {
+      setIsVerifying(true);
+      setError(null);
+      try {
+        const response = await client.verifySupportToken(token);
+        if (response.success && response.data) {
+          return {
+            tickets: response.data.tickets,
+            userEmail: response.data.user_email
+          };
+        } else {
+          setError(getErrorMessage(response.error, "Invalid or expired token"));
+          return null;
+        }
+      } catch (err) {
+        setError(getErrorMessage(err, "An error occurred"));
+        return null;
+      } finally {
+        setIsVerifying(false);
+      }
+    },
+    [client]
+  );
+  const getTicket = react.useCallback(
+    async (ticketId, token) => {
+      setError(null);
+      try {
+        const response = await client.getSupportTicket(ticketId, token);
+        if (response.success && response.data) {
+          return response.data;
+        } else {
+          setError(getErrorMessage(response.error, "Failed to fetch ticket"));
+          return null;
+        }
+      } catch (err) {
+        setError(getErrorMessage(err, "An error occurred"));
+        return null;
+      }
+    },
+    [client]
+  );
+  const addMessage = react.useCallback(
+    async (ticketId, token, content) => {
+      setError(null);
+      try {
+        const response = await client.addSupportMessage(ticketId, token, content);
+        if (response.success && response.data) {
+          return response.data;
+        } else {
+          setError(getErrorMessage(response.error, "Failed to add message"));
+          return null;
+        }
+      } catch (err) {
+        setError(getErrorMessage(err, "An error occurred"));
+        return null;
+      }
+    },
+    [client]
+  );
+  return {
+    isSubmitting,
+    isSendingMagicLink,
+    isVerifying,
+    error,
+    successMessage,
+    submitTicket,
+    requestMagicLink,
+    verifyToken,
+    getTicket,
+    addMessage,
+    clearMessages
+  };
+}
+
+exports.AppgramContext = AppgramContext;
+exports.cn = cn;
+exports.getErrorMessage = getErrorMessage;
+exports.getFingerprint = getFingerprint;
+exports.resetFingerprint = resetFingerprint;
+exports.useAppgramContext = useAppgramContext;
+exports.useComments = useComments;
+exports.useHelpArticle = useHelpArticle;
+exports.useHelpCenter = useHelpCenter;
+exports.useHelpFlow = useHelpFlow;
+exports.useRelease = useRelease;
+exports.useReleases = useReleases;
+exports.useRoadmap = useRoadmap;
+exports.useSupport = useSupport;
+exports.useVote = useVote;
+exports.useWishes = useWishes;
+//# sourceMappingURL=chunk-75P634IK.js.map
+//# sourceMappingURL=chunk-75P634IK.js.map