@mohasinac/appkit 2.3.0 → 2.3.2

package/dist/features/faq/components/FAQPageContent.d.ts

@@ -0,0 +1,57 @@
+import React from "react";
+import type { FAQCategory, FAQ } from "../types";
+import { type FAQCategoryItem } from "./FAQCategorySidebar";
+import { type FAQSortOption } from "./FAQSortDropdown";
+interface FAQPageContentProps {
+    initialCategory?: FAQCategory | "all";
+    categories: FAQCategoryItem[];
+    routeHelpers: {
+        allFaqsHref: string;
+        faqCategoryHref: (category: FAQCategory) => string;
+        contactHref: string;
+        navigateToCategory: (category: FAQCategory | "all") => void;
+    };
+    labels: {
+        title: string;
+        subtitle: string;
+        searchPlaceholder: string;
+        categoriesTitle: string;
+        allFaqs: string;
+        stillHaveQuestions: string;
+        contactSupport: string;
+        sortLabel: string;
+        sortHelpful: string;
+        sortNewest: string;
+        sortAlphabetical: string;
+        resultCount: (count: number) => string;
+        inCategory: (categoryLabel: string) => string;
+        loading: string;
+        contactTitle: string;
+        contactDescription: string;
+        contactEmailUs: string;
+        contactCallUs: string;
+        contactForm: string;
+        contactSubmitRequest: string;
+        contactTeam: string;
+    };
+    contact: {
+        email: string;
+        phone: string;
+    };
+    searchValue: string;
+    onSearchChange: (value: string) => void;
+    sortOption: FAQSortOption;
+    onSortChange: (sort: FAQSortOption) => void;
+    page?: number;
+    pageSize?: number;
+    renderPagination?: (total: number) => React.ReactNode;
+    renderMobileCategoryTabs: (input: {
+        selectedCategory: FAQCategory | "all";
+        total: number;
+        categoryCounts: Record<FAQCategory, number>;
+        onSelect: (value: FAQCategory | "all") => void;
+    }) => React.ReactNode;
+    renderAccordion?: (faqs: FAQ[]) => React.ReactNode;
+}
+export declare function FAQPageContent({ initialCategory, categories, routeHelpers, labels, contact, searchValue, onSearchChange, sortOption, onSortChange, page, pageSize, renderPagination, renderMobileCategoryTabs, renderAccordion, }: FAQPageContentProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/faq/components/FAQPageContent.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Heading, Input, SlottedListingView, Text } from "../../../ui";
+import { FAQCategorySidebar } from "./FAQCategorySidebar";
+import { FAQSortDropdown } from "./FAQSortDropdown";
+import { FAQAccordion } from "./FAQAccordion";
+import { ContactCTA } from "./ContactCTA";
+import { useFaqList } from "../hooks/useFaqList";
+export function FAQPageContent({ initialCategory = "all", categories, routeHelpers, labels, contact, searchValue, onSearchChange, sortOption, onSortChange, page = 1, pageSize = 100, renderPagination, renderMobileCategoryTabs, renderAccordion, }) {
+    const selectedCategory = initialCategory;
+    const sorts = sortOption === "helpful"
+        ? "-stats.helpful,-priority,order"
+        : sortOption === "alphabetical"
+            ? "question"
+            : "-createdAt";
+    const { faqs, total, isLoading } = useFaqList({
+        category: selectedCategory === "all" ? undefined : selectedCategory,
+        search: searchValue.trim() || undefined,
+        sorts,
+        page,
+        pageSize,
+    });
+    const { faqs: allMatchingFaqs } = useFaqList({
+        search: searchValue.trim() || undefined,
+        sorts: "-priority,order",
+        page: 1,
+        pageSize: 200,
+    });
+    const categoryCounts = categories.reduce((acc, category) => {
+        acc[category.key] = 0;
+        return acc;
+    }, {});
+    allMatchingFaqs.forEach((faq) => {
+        if (faq.category in categoryCounts) {
+            categoryCounts[faq.category] += 1;
+        }
+    });
+    const handleCategorySelect = (category) => {
+        routeHelpers.navigateToCategory(category);
+    };
+    return (_jsxs("div", { className: "py-12", "data-section": "faqpagecontent-div-287", children: [_jsxs("div", { className: "mb-12 text-center", "data-section": "faqpagecontent-div-288", children: [_jsx(Heading, { level: 1, className: "mb-4 text-3xl font-bold sm:text-4xl", children: labels.title }), _jsx(Text, { className: "mx-auto max-w-2xl text-zinc-600 dark:text-zinc-300", children: labels.subtitle })] }), _jsx("div", { className: "mb-8 lg:hidden", "data-section": "faqpagecontent-div-289", children: renderMobileCategoryTabs({
+                    selectedCategory,
+                    total,
+                    categoryCounts,
+                    onSelect: handleCategorySelect,
+                }) }), _jsxs("div", { className: "grid grid-cols-1 gap-8 lg:grid-cols-12", "data-section": "faqpagecontent-div-290", children: [_jsx("div", { className: "hidden lg:col-span-4 lg:block xl:col-span-3", "data-section": "faqpagecontent-div-291", children: _jsx(FAQCategorySidebar, { selectedCategory: selectedCategory, onCategorySelect: handleCategorySelect, categoryCounts: categoryCounts, categories: categories, allFaqsHref: routeHelpers.allFaqsHref, categoryHref: routeHelpers.faqCategoryHref, contactHref: routeHelpers.contactHref, labels: {
+                                title: labels.categoriesTitle,
+                                allFaqs: labels.allFaqs,
+                                stillHaveQuestions: labels.stillHaveQuestions,
+                                contactSupport: labels.contactSupport,
+                            } }) }), _jsxs("div", { className: "col-span-1 lg:col-span-8 xl:col-span-9", "data-section": "faqpagecontent-div-292", children: [_jsx(SlottedListingView, { portal: "public", inlineToolbar: true, className: "space-y-6", renderHeader: () => (_jsxs(Text, { className: "text-sm text-zinc-600 dark:text-zinc-300", children: [labels.resultCount(total), selectedCategory !== "all"
+                                            ? ` ${labels.inCategory(categories.find((c) => c.key === selectedCategory)?.label ?? selectedCategory)}`
+                                            : ""] })), renderSearch: () => (_jsx(Input, { value: searchValue, onChange: (event) => onSearchChange(event.target.value), placeholder: labels.searchPlaceholder })), renderSort: () => (_jsx(FAQSortDropdown, { selectedSort: sortOption, onSortChange: onSortChange, labels: {
+                                        label: labels.sortLabel,
+                                        helpful: labels.sortHelpful,
+                                        newest: labels.sortNewest,
+                                        alphabetical: labels.sortAlphabetical,
+                                    } })), renderTable: () => isLoading ? (_jsx(Text, { className: "text-zinc-500 dark:text-zinc-400", children: labels.loading })) : renderAccordion ? (renderAccordion(faqs)) : (_jsx(FAQAccordion, { faqs: faqs })), renderPagination: () => renderPagination?.(total) ?? null, total: total, isLoading: isLoading }), faqs.length > 0 ? (_jsx("div", { className: "mt-12", "data-section": "faqpagecontent-div-293", children: _jsx(ContactCTA, { email: contact.email, phone: contact.phone, contactHref: routeHelpers.contactHref, labels: {
+                                        title: labels.contactTitle,
+                                        description: labels.contactDescription,
+                                        emailUs: labels.contactEmailUs,
+                                        callUs: labels.contactCallUs,
+                                        contactForm: labels.contactForm,
+                                        submitRequest: labels.contactSubmitRequest,
+                                        contactTeam: labels.contactTeam,
+                                    } }) })) : null] })] })] }));
+}

package/dist/features/faq/components/FAQSortDropdown.d.ts

@@ -0,0 +1,13 @@
+export type FAQSortOption = "helpful" | "newest" | "alphabetical";
+interface FAQSortDropdownProps {
+    selectedSort: FAQSortOption;
+    onSortChange: (sort: FAQSortOption) => void;
+    labels?: {
+        label?: string;
+        helpful?: string;
+        newest?: string;
+        alphabetical?: string;
+    };
+}
+export declare function FAQSortDropdown({ selectedSort, onSortChange, labels, }: FAQSortDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/faq/components/FAQSortDropdown.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Select, Span } from "../../../ui";
+export function FAQSortDropdown({ selectedSort, onSortChange, labels, }) {
+    const sortOptions = [
+        { value: "helpful", label: labels?.helpful ?? "Most Helpful" },
+        { value: "newest", label: labels?.newest ?? "Newest" },
+        { value: "alphabetical", label: labels?.alphabetical ?? "Alphabetical" },
+    ];
+    return (_jsxs("div", { className: "flex items-center gap-3", "data-section": "faqsortdropdown-div-294", children: [_jsx(Span, { className: "text-sm text-zinc-600 dark:text-zinc-400", children: labels?.label ?? "Sort" }), _jsx("div", { className: "min-w-44", "data-section": "faqsortdropdown-div-295", children: _jsx(Select, { value: selectedSort, onValueChange: (value) => onSortChange(value), options: sortOptions }) })] }));
+}

package/dist/features/faq/components/RelatedFAQs.d.ts

@@ -0,0 +1,10 @@
+import type { FAQ } from "../types";
+interface RelatedFAQsProps {
+    relatedFAQs: FAQ[];
+    hrefForFaq?: (faq: FAQ) => string;
+    labels?: {
+        title?: string;
+    };
+}
+export declare function RelatedFAQs({ relatedFAQs, hrefForFaq, labels, }: RelatedFAQsProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/faq/components/RelatedFAQs.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Card, Div, Heading, Text, TextLink } from "../../../ui";
+export function RelatedFAQs({ relatedFAQs, hrefForFaq, labels, }) {
+    if (!relatedFAQs || relatedFAQs.length === 0) {
+        return null;
+    }
+    return (_jsxs(Card, { variant: "outlined", padding: "lg", className: "dark:bg-slate-800/60", children: [_jsx(Heading, { level: 3, className: "mb-4 text-lg font-semibold", children: labels?.title ?? "Related Questions" }), _jsx(Div, { className: "space-y-3", children: relatedFAQs.map((faq) => (_jsx(TextLink, { href: hrefForFaq ? hrefForFaq(faq) : `/faqs#${faq.id}`, className: "group block rounded-lg bg-zinc-100 p-4 transition-colors hover:bg-zinc-200 dark:bg-slate-700 dark:hover:bg-slate-600", children: _jsxs(Div, { className: "flex items-start gap-3", children: [_jsx("svg", { className: "mt-0.5 h-5 w-5 flex-shrink-0 text-zinc-500 dark:text-zinc-400", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M8.228 9c.549-1.165 2.03-2 3.772-2 2.21 0 4 1.343 4 3 0 1.4-1.278 2.575-3.006 2.907-.542.104-.994.54-.994 1.093m0 3h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" }) }), _jsx(Text, { className: "text-sm text-zinc-800 transition-colors group-hover:text-primary dark:text-zinc-100", children: faq.question }), _jsx("svg", { className: "ml-auto mt-0.5 h-4 w-4 flex-shrink-0 text-zinc-500 opacity-0 transition-opacity group-hover:opacity-100 dark:text-zinc-400", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24", children: _jsx("path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M9 5l7 7-7 7" }) })] }) }, faq.id))) })] }));
+}

package/dist/features/faq/components/index.d.ts

@@ -0,0 +1,9 @@
+export { FAQAccordion, FAQCategoryTabs } from "./FAQAccordion";
+export { FAQCategorySidebar } from "./FAQCategorySidebar";
+export type { FAQCategoryItem } from "./FAQCategorySidebar";
+export { FAQSortDropdown } from "./FAQSortDropdown";
+export type { FAQSortOption } from "./FAQSortDropdown";
+export { FAQHelpfulButtons } from "./FAQHelpfulButtons";
+export { RelatedFAQs } from "./RelatedFAQs";
+export { ContactCTA } from "./ContactCTA";
+export { FAQPageContent } from "./FAQPageContent";

package/dist/features/faq/components/index.js

@@ -0,0 +1,7 @@
+export { FAQAccordion, FAQCategoryTabs } from "./FAQAccordion";
+export { FAQCategorySidebar } from "./FAQCategorySidebar";
+export { FAQSortDropdown } from "./FAQSortDropdown";
+export { FAQHelpfulButtons } from "./FAQHelpfulButtons";
+export { RelatedFAQs } from "./RelatedFAQs";
+export { ContactCTA } from "./ContactCTA";
+export { FAQPageContent } from "./FAQPageContent";

package/dist/features/faq/hooks/useFAQs.d.ts

@@ -0,0 +1,22 @@
+import type { FAQ, FAQListResponse, FAQListParams } from "../types";
+interface UseFAQsOptions {
+    initialData?: FAQListResponse;
+    enabled?: boolean;
+    endpoint?: string;
+}
+export declare function useFAQs(params?: FAQListParams, opts?: UseFAQsOptions): {
+    faqs: FAQ[];
+    total: number;
+    isLoading: boolean;
+    error: Error | null;
+};
+export declare function useFAQ(id: string, opts?: {
+    initialData?: FAQ;
+    enabled?: boolean;
+    endpoint?: string;
+}): {
+    faq: FAQ | undefined;
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/features/faq/hooks/useFAQs.js

@@ -0,0 +1,41 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { FAQ_ENDPOINTS } from "../../../constants/api-endpoints";
+export function useFAQs(params = {}, opts) {
+    const sp = new URLSearchParams();
+    if (params.category)
+        sp.set("category", params.category);
+    if (params.homepage !== undefined)
+        sp.set("homepage", String(params.homepage));
+    if (params.q)
+        sp.set("q", params.q);
+    if (params.page)
+        sp.set("page", String(params.page));
+    if (params.perPage)
+        sp.set("perPage", String(params.perPage));
+    const qs = sp.toString();
+    const endpoint = opts?.endpoint ?? `${FAQ_ENDPOINTS.LIST}${qs ? `?${qs}` : ""}`;
+    const query = useQuery({
+        queryKey: ["faqs", qs],
+        queryFn: () => apiClient.get(endpoint),
+        initialData: opts?.initialData,
+        enabled: opts?.enabled,
+        staleTime: 10 * 60 * 1000,
+    });
+    return {
+        faqs: query.data?.items ?? [],
+        total: query.data?.total ?? 0,
+        isLoading: query.isLoading,
+        error: query.error,
+    };
+}
+export function useFAQ(id, opts) {
+    const endpoint = opts?.endpoint ?? FAQ_ENDPOINTS.BY_ID(id);
+    const query = useQuery({
+        queryKey: ["faqs", id],
+        queryFn: () => apiClient.get(endpoint),
+        initialData: opts?.initialData,
+        enabled: opts?.enabled !== false && !!id,
+    });
+    return { faq: query.data, isLoading: query.isLoading, error: query.error };
+}

package/dist/features/faq/hooks/useFaqList.d.ts

@@ -0,0 +1,194 @@
+import type { FAQCategory, FAQListResponse } from "../types";
+interface UseFaqListOptions {
+    category?: FAQCategory;
+    search?: string;
+    tags?: string[];
+    showOnHomepage?: boolean;
+    page?: number;
+    pageSize?: number;
+    sorts?: string;
+    enabled?: boolean;
+    initialData?: FAQListResponse;
+}
+export declare function useFaqList(options?: UseFaqListOptions): {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: FAQListResponse;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+} | {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: FAQListResponse;
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+} | {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+} | {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+} | {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+} | {
+    faqs: import("..").FAQ[];
+    total: number;
+    categories: readonly string[];
+    data: FAQListResponse;
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<FAQListResponse, Error>>;
+    fetchStatus: import("@tanstack/query-core").FetchStatus;
+    promise: Promise<FAQListResponse>;
+};
+export {};

package/dist/features/faq/hooks/useFaqList.js

@@ -0,0 +1,34 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { FAQ_ENDPOINTS } from "../../../constants/api-endpoints";
+export function useFaqList(options = {}) {
+    const params = new URLSearchParams();
+    if (options.category)
+        params.set("category", options.category);
+    if (options.search)
+        params.set("search", options.search);
+    if (options.tags && options.tags.length > 0) {
+        params.set("tags", options.tags.join(","));
+    }
+    if (options.showOnHomepage !== undefined) {
+        params.set("showOnHomepage", String(options.showOnHomepage));
+    }
+    params.set("page", String(options.page ?? 1));
+    params.set("pageSize", String(options.pageSize ?? 20));
+    if (options.sorts)
+        params.set("sorts", options.sorts);
+    const queryString = params.toString();
+    const query = useQuery({
+        queryKey: ["faqs", queryString],
+        queryFn: () => apiClient.get(`${FAQ_ENDPOINTS.LIST}${queryString ? `?${queryString}` : ""}`),
+        enabled: options.enabled,
+        initialData: options.initialData,
+        staleTime: 5 * 60 * 1000,
+    });
+    return {
+        ...query,
+        faqs: query.data?.items ?? [],
+        total: query.data?.total ?? 0,
+        categories: query.data?.categories ?? [],
+    };
+}

package/dist/features/faq/hooks/useFaqVote.d.ts

@@ -0,0 +1,14 @@
+export interface VoteFaqInput {
+    faqId: string;
+    vote: "helpful" | "not_helpful" | "not-helpful";
+}
+export interface VoteFaqResult {
+    helpfulCount: number;
+    notHelpfulCount?: number;
+    userVote?: VoteFaqInput["vote"] | null;
+}
+export interface UseFaqVoteOptions {
+    mutationFn?: (data: VoteFaqInput) => Promise<VoteFaqResult>;
+    endpoint?: string;
+}
+export declare function useFaqVote(options?: UseFaqVoteOptions): import("@tanstack/react-query").UseMutationResult<VoteFaqResult, Error, VoteFaqInput, unknown>;

package/dist/features/faq/hooks/useFaqVote.js

@@ -0,0 +1,9 @@
+import { useMutation } from "@tanstack/react-query";
+import { apiClient } from "../../../http";
+import { FAQ_ENDPOINTS } from "../../../constants/api-endpoints";
+export function useFaqVote(options) {
+    return useMutation({
+        mutationFn: options?.mutationFn ??
+            ((data) => apiClient.post(options?.endpoint ?? FAQ_ENDPOINTS.VOTE, data)),
+    });
+}

package/dist/features/faq/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./hooks/useFAQs";
+export * from "./hooks/useFaqList";
+export * from "./hooks/useFaqVote";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";

package/dist/features/faq/index.js

@@ -0,0 +1,8 @@
+export * from "./types";
+export * from "./hooks/useFAQs";
+export * from "./hooks/useFaqList";
+export * from "./hooks/useFaqVote";
+export * from "./components";
+export * from "./schemas";
+export * from "./columns";
+export { manifest } from "./manifest";

package/dist/features/faq/manifest.d.ts

@@ -0,0 +1,2 @@
+import type { FeatureManifest } from "../../contracts";
+export declare const manifest: FeatureManifest;

package/dist/features/faq/manifest.js

@@ -0,0 +1,10 @@
+export const manifest = {
+    name: "faq",
+    i18nNamespace: "faq",
+    envKeys: [],
+    routes: [{ segment: "[locale]/faq", exports: { default: "FAQPageView" } }],
+    apiRoutes: [
+        { segment: "api/faqs", methods: ["GET", "POST"] },
+        { segment: "api/faqs/[id]", methods: ["GET", "PATCH", "DELETE"] },
+    ],
+};

package/dist/features/faq/messages/en.json

@@ -0,0 +1,14 @@
+{
+  "title": "Frequently Asked Questions",
+  "all": "All",
+  "noFAQs": "No questions found",
+  "category": {
+    "orders_payment": "Orders & Payment",
+    "shipping_delivery": "Shipping & Delivery",
+    "returns_refunds": "Returns & Refunds",
+    "product_information": "Product Information",
+    "account_security": "Account & Security",
+    "technical_support": "Technical Support",
+    "general": "General"
+  }
+}

package/dist/features/faq/repository/faqs.repository.d.ts

@@ -0,0 +1,42 @@
+import type { IRepository, PagedResult, SieveQuery } from "../../../contracts";
+import { BaseRepository } from "../../../providers/db-firebase";
+import type { FirebaseSieveFields, FirebaseSieveResult, SieveModel } from "../../../providers/db-firebase";
+import type { FAQ, FAQCategory } from "../types";
+import { FAQDocument, FAQCreateInput, FAQWithInterpolatedAnswer } from "../schemas";
+export declare class FAQsRepository {
+    private readonly repo;
+    constructor(repo: IRepository<FAQ>);
+    findAll(query?: SieveQuery): Promise<PagedResult<FAQ>>;
+    findByCategory(category: FAQCategory): Promise<FAQ[]>;
+    findForHomepage(): Promise<FAQ[]>;
+    findForFooter(): Promise<FAQ[]>;
+    findById(id: string): Promise<FAQ | null>;
+    create(data: Omit<FAQ, "id">): Promise<FAQ>;
+    update(id: string, data: Partial<FAQ>): Promise<FAQ>;
+    delete(id: string): Promise<void>;
+}
+export declare class FirebaseFAQsRepository extends BaseRepository<FAQDocument> {
+    static readonly SIEVE_FIELDS: FirebaseSieveFields;
+    constructor();
+    private buildSearchTokens;
+    create(data: Partial<FAQDocument>): Promise<FAQDocument>;
+    update(id: string, data: Partial<FAQDocument>): Promise<FAQDocument>;
+    list(model: SieveModel, opts?: {
+        tags?: string[];
+        search?: string;
+    }): Promise<FirebaseSieveResult<FAQDocument>>;
+    getFAQBySlug(slug: string): Promise<FAQDocument | null>;
+    getFAQsByCategory(category: FAQCategory): Promise<FAQDocument[]>;
+    getHomepageFAQs(): Promise<FAQDocument[]>;
+    getFooterFAQs(): Promise<FAQDocument[]>;
+    getPinnedFAQs(category?: FAQCategory): Promise<FAQDocument[]>;
+    searchByTag(tag: string): Promise<FAQDocument[]>;
+    getMostHelpful(limit?: number): Promise<FAQDocument[]>;
+    interpolateVariables(faq: FAQDocument, variables?: Record<string, string | number>): Promise<FAQWithInterpolatedAnswer>;
+    incrementViews(faqId: string): Promise<void>;
+    markHelpful(faqId: string): Promise<void>;
+    markNotHelpful(faqId: string): Promise<void>;
+    createWithSlug(input: FAQCreateInput): Promise<FAQDocument>;
+    getRelatedFAQs(faqId: string): Promise<FAQDocument[]>;
+}
+export declare const faqsRepository: FirebaseFAQsRepository;