@mohasinac/appkit 2.3.0 → 2.3.1

package/dist/features/events/columns/index.js

@@ -0,0 +1,41 @@
+import { buildColumns, renderCount } from "../../../ui/columns";
+/**
+ * Default admin column definitions for an event table.
+ *
+ * @example
+ * const columns = buildEventColumns<MyEvent>({
+ *   overrides: { title: { render: (e) => <Link href={e.id}>{e.title}</Link> } },
+ *   extras: [{ key: "brandId", header: "Brand", render: (e) => e.brandId ?? "—" }],
+ * });
+ */
+export const eventAdminColumns = [
+    { key: "title", header: "Title", sortable: true },
+    { key: "type", header: "Type", sortable: true },
+    { key: "status", header: "Status", sortable: true },
+    { key: "startsAt", header: "Starts At", sortable: true },
+    { key: "endsAt", header: "Ends At", sortable: true },
+    {
+        key: "totalEntries",
+        header: "Entries",
+        sortable: true,
+        render: (e) => renderCount(e.stats.totalEntries),
+    },
+    {
+        key: "flaggedEntries",
+        header: "Flagged",
+        render: (e) => renderCount(e.stats.flaggedEntries),
+    },
+    { key: "createdAt", header: "Created", sortable: true },
+];
+/**
+ * Build a merged column list from the base event columns.
+ *
+ * @example
+ * const cols = buildEventColumns<MyEvent>({
+ *   omit: ["flaggedEntries"],
+ *   extras: [{ key: "rewardPoints", header: "Points", render: (e) => e.rewardPoints }],
+ * });
+ */
+export function buildEventColumns(opts) {
+    return buildColumns(eventAdminColumns, opts);
+}

package/dist/features/events/components/AdminEventEntriesView.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import type { StackedViewShellProps } from "../../../ui";
+export interface AdminEventEntriesViewProps extends Omit<StackedViewShellProps, "sections"> {
+    eventId?: string;
+    entriesEndpoint?: (eventId: string) => string;
+    entryReviewEndpoint?: (eventId: string, entryId: string) => string;
+    statsEndpoint?: (eventId: string) => string;
+    children?: React.ReactNode;
+    /** Back-link and event title header */
+    renderHeader?: () => React.ReactNode;
+    /** Stats banner (total / approved / flagged counts) */
+    renderStats?: () => React.ReactNode;
+    /** Filter bar (status dropdown, sort, search) */
+    renderFilters?: () => React.ReactNode;
+    /** Entries data table */
+    renderTable?: () => React.ReactNode;
+    /** Pagination footer */
+    renderPagination?: () => React.ReactNode;
+    /** Entry review side-drawer */
+    renderReviewDrawer?: () => React.ReactNode;
+}
+export declare function AdminEventEntriesView({ eventId, entriesEndpoint, entryReviewEndpoint, statsEndpoint, renderHeader, renderStats, renderFilters, renderTable, renderPagination, renderReviewDrawer, ...rest }: AdminEventEntriesViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/events/components/AdminEventEntriesView.js

@@ -0,0 +1,117 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { Alert, Button, Input, Select, StackedViewShell, Text, } from "../../../ui";
+import { apiClient } from "../../../http";
+import { DataTable } from "../../admin/components/DataTable";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
+const REVIEW_STATUS_OPTIONS = [
+    { label: "All", value: "all" },
+    { label: "Pending", value: "pending" },
+    { label: "Approved", value: "approved" },
+    { label: "Flagged", value: "flagged" },
+];
+export function AdminEventEntriesView({ eventId, entriesEndpoint, entryReviewEndpoint, statsEndpoint, renderHeader, renderStats, renderFilters, renderTable, renderPagination, renderReviewDrawer, ...rest }) {
+    const queryClient = useQueryClient();
+    const [page, setPage] = React.useState(1);
+    const [pageSize] = React.useState(20);
+    const [statusFilter, setStatusFilter] = React.useState("all");
+    const [searchQuery, setSearchQuery] = React.useState("");
+    const resolvedEntriesEndpoint = React.useMemo(() => {
+        if (!eventId)
+            return "";
+        return entriesEndpoint?.(eventId) ?? ADMIN_ENDPOINTS.EVENT_ENTRIES(eventId);
+    }, [entriesEndpoint, eventId]);
+    const resolvedStatsEndpoint = React.useMemo(() => {
+        if (!eventId)
+            return "";
+        return statsEndpoint?.(eventId) ?? ADMIN_ENDPOINTS.EVENT_STATS(eventId);
+    }, [eventId, statsEndpoint]);
+    const entriesQuery = useQuery({
+        queryKey: [
+            "admin-event-entries",
+            eventId,
+            resolvedEntriesEndpoint,
+            page,
+            pageSize,
+            statusFilter,
+            searchQuery,
+        ],
+        queryFn: () => {
+            const sp = new URLSearchParams();
+            sp.set("page", String(page));
+            sp.set("pageSize", String(pageSize));
+            if (statusFilter !== "all")
+                sp.set("reviewStatus", statusFilter);
+            if (searchQuery.trim())
+                sp.set("q", searchQuery.trim());
+            return apiClient.get(`${resolvedEntriesEndpoint}?${sp.toString()}`);
+        },
+        enabled: Boolean(eventId && resolvedEntriesEndpoint),
+        staleTime: 15000,
+    });
+    const statsQuery = useQuery({
+        queryKey: ["admin-event-stats", eventId, resolvedStatsEndpoint],
+        queryFn: () => apiClient.get(resolvedStatsEndpoint),
+        enabled: Boolean(eventId && resolvedStatsEndpoint),
+        staleTime: 15000,
+    });
+    const reviewMutation = useMutation({
+        mutationFn: async ({ entryId, status, }) => {
+            if (!eventId)
+                throw new Error("eventId is required");
+            const endpoint = entryReviewEndpoint?.(eventId, entryId) ??
+                ADMIN_ENDPOINTS.EVENT_ENTRY_BY_ID(eventId, entryId);
+            await apiClient.patch(endpoint, { status });
+        },
+        onSuccess: async () => {
+            await Promise.all([
+                queryClient.invalidateQueries({ queryKey: ["admin-event-entries", eventId] }),
+                queryClient.invalidateQueries({ queryKey: ["admin-event-stats", eventId] }),
+            ]);
+        },
+    });
+    const rows = entriesQuery.data?.items ?? [];
+    const columns = React.useMemo(() => [
+        {
+            key: "submittedAt",
+            header: "Submitted",
+            render: (row) => new Date(row.submittedAt).toLocaleString(),
+        },
+        {
+            key: "userDisplayName",
+            header: "User",
+            render: (row) => row.userDisplayName || row.userEmail || row.userId || "Anonymous",
+        },
+        {
+            key: "reviewStatus",
+            header: "Status",
+            render: (row) => (_jsx(Text, { className: "text-xs font-medium uppercase tracking-wide", children: row.reviewStatus })),
+        },
+        {
+            key: "actions",
+            header: "Actions",
+            render: (row) => (_jsxs("div", { className: "flex items-center gap-2", "data-section": "adminevententriesview-div-274", children: [_jsx(Button, { size: "sm", variant: "secondary", disabled: reviewMutation.isPending || row.reviewStatus === "approved", onClick: () => reviewMutation.mutate({ entryId: row.id, status: "approved" }), children: "Approve" }), _jsx(Button, { size: "sm", variant: "outline", disabled: reviewMutation.isPending || row.reviewStatus === "flagged", onClick: () => reviewMutation.mutate({ entryId: row.id, status: "flagged" }), children: "Flag" })] })),
+        },
+    ], [reviewMutation]);
+    const statsSection = (_jsxs("div", { className: "grid grid-cols-1 sm:grid-cols-3 gap-3", "data-section": "adminevententriesview-div-275", children: [_jsx(Alert, { variant: "info", title: "Total entries", children: String(statsQuery.data?.stats?.totalEntries ?? 0) }), _jsx(Alert, { variant: "success", title: "Approved", children: String(statsQuery.data?.stats?.approvedEntries ?? 0) }), _jsx(Alert, { variant: "warning", title: "Flagged", children: String(statsQuery.data?.stats?.flaggedEntries ?? 0) })] }));
+    const filtersSection = (_jsxs("div", { className: "grid grid-cols-1 md:grid-cols-3 gap-3", "data-section": "adminevententriesview-div-276", children: [_jsx(Input, { label: "Search entries", value: searchQuery, onChange: (event) => {
+                    setPage(1);
+                    setSearchQuery(event.target.value);
+                }, placeholder: "Search by user, email, or id" }), _jsx(Select, { label: "Review status", value: statusFilter, options: REVIEW_STATUS_OPTIONS, onChange: (event) => {
+                    setPage(1);
+                    setStatusFilter(event.target.value);
+                } })] }));
+    const tableSection = (_jsx(DataTable, { columns: columns, rows: rows, isLoading: entriesQuery.isLoading, currentPage: entriesQuery.data?.page ?? page, totalPages: entriesQuery.data?.totalPages ?? 1, onPageChange: setPage, emptyLabel: "No entries found" }));
+    const eventTitle = statsQuery.data?.event?.title;
+    return (_jsx(StackedViewShell, { portal: "admin", ...rest, title: eventTitle ? `${eventTitle} Entries` : "Event Entries", renderHeader: renderHeader, sections: [
+            !eventId ? (_jsx(Alert, { variant: "warning", title: "Missing event id", children: "Event id is required to load entries." })) : null,
+            entriesQuery.error ? (_jsx(Alert, { variant: "error", title: "Could not load entries", children: entriesQuery.error instanceof Error ? entriesQuery.error.message : "Unknown error" })) : null,
+            statsQuery.error ? (_jsx(Alert, { variant: "error", title: "Could not load event stats", children: statsQuery.error instanceof Error ? statsQuery.error.message : "Unknown error" })) : null,
+            renderStats?.() ?? statsSection,
+            renderFilters?.() ?? filtersSection,
+            renderTable?.() ?? tableSection,
+            renderPagination?.(),
+        ], overlays: renderReviewDrawer?.() }));
+}

package/dist/features/events/components/AdminEventsView.d.ts

@@ -0,0 +1,4 @@
+import type { ListingViewShellProps } from "../../../ui";
+export interface AdminEventsViewProps extends ListingViewShellProps {
+}
+export declare function AdminEventsView({ children, ...props }: AdminEventsViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/events/components/AdminEventsView.js

@@ -0,0 +1,35 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import React from "react";
+import { ListingViewShell } from "../../../ui";
+import { ADMIN_ENDPOINTS } from "../../../constants/api-endpoints";
+import { toRecordArray, toRelativeDate, toStringValue, useAdminListingData, } from "../../admin/hooks/useAdminListingData";
+import { AdminListingScaffold } from "../../admin/components/AdminListingScaffold";
+export function AdminEventsView({ children, ...props }) {
+    const hasChildren = React.Children.count(children) > 0;
+    const { rows, total, isLoading, errorMessage } = useAdminListingData({
+        queryKey: ["admin", "events", "listing"],
+        endpoint: ADMIN_ENDPOINTS.EVENTS,
+        mapRows: (response) => toRecordArray(response.items).map((item, index) => ({
+            id: toStringValue(item.id, `event-${index}`),
+            primary: toStringValue(item.title, "Untitled event"),
+            secondary: [
+                toStringValue(item.type, "event"),
+                toStringValue(item.startsAt, ""),
+            ]
+                .filter(Boolean)
+                .join(" · "),
+            status: toStringValue(item.status, "active"),
+            updatedAt: toRelativeDate(item.updatedAt ?? item.createdAt),
+        })),
+        getTotal: (response, mappedRows) => {
+            if (typeof response.total === "number")
+                return response.total;
+            return mappedRows.length;
+        },
+    });
+    if (hasChildren) {
+        return _jsx(ListingViewShell, { portal: "admin", ...props, children: children });
+    }
+    return (_jsx(AdminListingScaffold, { portal: "admin", ...props, title: "Events", subtitle: "Manage sales events, offers, polls, surveys, and feedback campaigns.", actionLabel: "New event", searchPlaceholder: "Search events by title or type", rows: rows, isLoading: isLoading, errorMessage: errorMessage, emptyLabel: "No events found", resultSummary: `Showing ${rows.length} of ${total} events` }));
+}

package/dist/features/events/components/EventBanner.d.ts

@@ -0,0 +1,13 @@
+export interface EventBannerProps {
+    storageKey?: string;
+    className?: string;
+    saleHref?: string;
+    getOfferHref?: (eventId: string) => string;
+    labels?: {
+        saleBanner?: (discountPercent: number) => string;
+        offerBanner?: (offerCode: string) => string;
+        dismissAriaLabel?: string;
+    };
+}
+export declare function EventBanner({ storageKey, className, saleHref, getOfferHref, labels, }: EventBannerProps): import("react/jsx-runtime").JSX.Element | null;
+export default EventBanner;

package/dist/features/events/components/EventBanner.js

@@ -0,0 +1,48 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState } from "react";
+import { useEvents } from "../hooks/useEvents";
+import { Button, TextLink } from "../../../ui";
+export function EventBanner({ storageKey = "dismissed_event_banners", className = "", saleHref = "/products", getOfferHref = (eventId) => `/events/${eventId}`, labels, }) {
+    const [dismissedIds, setDismissedIds] = useState([]);
+    const [mounted, setMounted] = useState(false);
+    useEffect(() => {
+        try {
+            const stored = sessionStorage.getItem(storageKey);
+            if (stored)
+                setDismissedIds(JSON.parse(stored));
+        }
+        catch {
+            // ignore session storage failures
+        }
+        setMounted(true);
+    }, [storageKey]);
+    const { events } = useEvents({ pageSize: 1, sort: "-startsAt" });
+    const event = useMemo(() => events.find((candidate) => (candidate.type === "sale" || candidate.type === "offer") &&
+        !dismissedIds.includes(candidate.id)), [dismissedIds, events]);
+    if (!mounted || !event)
+        return null;
+    const isSale = event.type === "sale";
+    const discountPct = event.saleConfig?.discountPercent ?? 0;
+    const offerCode = event.offerConfig?.displayCode ?? "";
+    const text = isSale
+        ? (labels?.saleBanner?.(discountPct) ??
+            `Sale live: up to ${discountPct}% off`)
+        : (labels?.offerBanner?.(offerCode) ?? `Offer live: use ${offerCode}`);
+    const href = isSale ? saleHref : getOfferHref(event.id);
+    const dismiss = () => {
+        const next = [...dismissedIds, event.id];
+        setDismissedIds(next);
+        try {
+            sessionStorage.setItem(storageKey, JSON.stringify(next));
+        }
+        catch {
+            // ignore
+        }
+    };
+    return (_jsxs("div", { className: [
+            "relative bg-gradient-to-r from-indigo-600 to-violet-600 px-4 py-2 text-center text-sm font-medium text-white",
+            className,
+        ].join(" "), "data-section": "eventbanner-div-277", children: [_jsx(TextLink, { href: href, className: "hover:underline", children: text }), _jsx(Button, { type: "button", variant: "ghost", onClick: dismiss, "aria-label": labels?.dismissAriaLabel ?? "Dismiss banner", className: "absolute right-3 top-1/2 -translate-y-1/2 text-white/80 hover:text-white", children: "\u00D7" })] }));
+}
+export default EventBanner;

package/dist/features/events/components/EventCard.d.ts

@@ -0,0 +1,14 @@
+import type { EventItem } from "../types";
+interface EventCardProps {
+    event: EventItem;
+    labels?: {
+        participate?: string;
+        viewDetails?: string;
+        viewResults?: string;
+        entries?: string;
+    };
+    onParticipate?: (event: EventItem) => void;
+    className?: string;
+}
+export declare function EventCard({ event, labels, onParticipate, className, }: EventCardProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/events/components/EventCard.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Article, Button, Div, Heading, RichText, Span, TextLink } from "../../../ui";
+import { THEME_CONSTANTS, LAYOUT } from "../../../tokens";
+import { normalizeRichTextHtml } from "../../../utils/string.formatter";
+import { EVENT_FIELDS } from "../schemas";
+import { EventStatusBadge } from "./EventStatusBadge";
+import { ROUTES } from "../../../next";
+const TYPE_ICONS = {
+    sale: "🏷️",
+    offer: "🎁",
+    poll: "📊",
+    survey: "📝",
+    feedback: "💬",
+};
+export function EventCard({ event, labels = {}, onParticipate, className = "", }) {
+    const safeTitle = event.title?.trim() || "Untitled event";
+    const now = new Date();
+    const endsAt = new Date(event.endsAt);
+    const msLeft = endsAt.getTime() - now.getTime();
+    const daysLeft = Math.max(0, Math.ceil(msLeft / (1000 * 60 * 60 * 24)));
+    return (_jsxs(Article, { className: `flex h-full ${LAYOUT.cardHeight.event} flex-col overflow-hidden rounded-xl border border-zinc-200 bg-white shadow-sm transition-shadow hover:shadow-md dark:border-slate-700 dark:bg-slate-900 ${className}`, children: [event.coverImageUrl ? (_jsx(Div, { className: "aspect-video overflow-hidden", children: _jsx(Div, { role: "img", "aria-label": safeTitle, className: "h-full w-full bg-cover bg-center", style: { backgroundImage: `url(${event.coverImageUrl})` } }) })) : (_jsx(Div, { className: "aspect-video bg-gradient-to-br from-zinc-100 to-zinc-200 dark:from-slate-800 dark:to-slate-700" })), _jsxs(Div, { className: "flex flex-1 flex-col p-4", children: [_jsxs(Div, { className: "flex items-start justify-between gap-2 mb-2", children: [_jsx(Span, { className: "text-lg", "aria-hidden": "true", children: TYPE_ICONS[event.type] }), _jsx(EventStatusBadge, { status: event.status })] }), _jsx(Heading, { level: 3, className: "font-semibold text-gray-900 dark:text-zinc-100 text-base leading-snug mb-1", children: safeTitle }), _jsx(RichText, { html: normalizeRichTextHtml(event.description ?? ""), proseClass: "prose prose-sm max-w-none dark:prose-invert prose-p:my-0", className: `mb-3 ${THEME_CONSTANTS.utilities.textClamp3} text-sm text-zinc-600 dark:text-zinc-400` }), _jsxs(Div, { className: "mb-3 mt-auto flex items-center justify-between text-xs text-zinc-500 dark:text-zinc-500", children: [event.status === EVENT_FIELDS.STATUS_VALUES.ACTIVE &&
+                                daysLeft > 0 && _jsxs(Span, { children: [daysLeft, "d remaining"] }), _jsxs(Span, { children: [event.stats.totalEntries, " ", labels.entries ?? "entries"] })] }), event.status === EVENT_FIELDS.STATUS_VALUES.ACTIVE && onParticipate ? (_jsx(Button, { type: "button", onClick: () => onParticipate(event), className: "w-full rounded-lg bg-primary py-2 text-sm font-medium text-white transition-colors hover:bg-primary-600", children: labels.participate ?? "Participate" })) : (_jsx(TextLink, { href: ROUTES.PUBLIC.EVENT_DETAIL(event.id), className: "inline-flex w-full items-center justify-center rounded-lg border border-zinc-300 px-3 py-2 text-sm font-medium text-zinc-700 transition-colors hover:bg-zinc-100 dark:border-slate-600 dark:text-zinc-200 dark:hover:bg-slate-800", children: labels.viewDetails ?? "View details" }))] })] }));
+}

package/dist/features/events/components/EventDetailView.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { DetailViewShellProps } from "../../../ui";
+export interface EventDetailViewProps extends Omit<DetailViewShellProps, "mainSlots" | "layout"> {
+    /** Render the cover image */
+    renderCoverImage?: () => React.ReactNode;
+    /** Render status badge + basic header (title, dates) */
+    renderHeader?: () => React.ReactNode;
+    /** Render the type-specific interactive section (poll / survey / feedback / offer CTA) */
+    renderContent?: () => React.ReactNode;
+    /** Render an optional leaderboard section */
+    renderLeaderboard?: () => React.ReactNode;
+    /** Render a "participate" / "enter now" call-to-action when the event is active */
+    renderParticipateAction?: () => React.ReactNode;
+}
+export declare function EventDetailView({ renderCoverImage, renderHeader, renderContent, renderLeaderboard, renderParticipateAction, isLoading, ...rest }: EventDetailViewProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/events/components/EventDetailView.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { DetailViewShell } from "../../../ui";
+export function EventDetailView({ renderCoverImage, renderHeader, renderContent, renderLeaderboard, renderParticipateAction, isLoading = false, ...rest }) {
+    return (_jsx(DetailViewShell, { portal: "public", ...rest, layout: "narrow", isLoading: isLoading, mainSlots: [
+            renderCoverImage?.(),
+            renderHeader?.(),
+            renderContent?.(),
+            renderParticipateAction?.(),
+            renderLeaderboard?.(),
+        ] }));
+}

package/dist/features/events/components/EventFilters.d.ts

@@ -0,0 +1,105 @@
+import type { UrlTable } from "../../filters/FilterPanel";
+export type EventFilterVariant = "admin" | "seller" | "public";
+export declare const EVENT_FILTER_KEYS: {
+    readonly admin: readonly ["type", "status", "dateFrom", "dateTo"];
+    readonly seller: readonly ["type", "status", "dateFrom", "dateTo"];
+    readonly public: readonly ["type", "status", "dateFrom", "dateTo"];
+};
+export declare const EVENT_ADMIN_SORT_OPTIONS: readonly [{
+    readonly value: "title";
+    readonly label: "Title A–Z";
+}, {
+    readonly value: "-title";
+    readonly label: "Title Z–A";
+}, {
+    readonly value: "-startsAt";
+    readonly label: "Starts Latest";
+}, {
+    readonly value: "startsAt";
+    readonly label: "Starts Soonest";
+}, {
+    readonly value: "-endsAt";
+    readonly label: "Ends Latest";
+}, {
+    readonly value: "endsAt";
+    readonly label: "Ends Soonest";
+}, {
+    readonly value: "-stats.totalEntries";
+    readonly label: "Most Entries";
+}, {
+    readonly value: "-createdAt";
+    readonly label: "Newest First";
+}];
+export declare const EVENT_SELLER_SORT_OPTIONS: readonly [{
+    readonly value: "title";
+    readonly label: "Title A–Z";
+}, {
+    readonly value: "-title";
+    readonly label: "Title Z–A";
+}, {
+    readonly value: "-startsAt";
+    readonly label: "Starts Latest";
+}, {
+    readonly value: "startsAt";
+    readonly label: "Starts Soonest";
+}, {
+    readonly value: "-endsAt";
+    readonly label: "Ends Latest";
+}, {
+    readonly value: "endsAt";
+    readonly label: "Ends Soonest";
+}, {
+    readonly value: "-stats.totalEntries";
+    readonly label: "Most Entries";
+}, {
+    readonly value: "-createdAt";
+    readonly label: "Newest First";
+}];
+export declare const EVENT_PUBLIC_SORT_OPTIONS: readonly [{
+    readonly value: "startsAt";
+    readonly label: "Starts Soonest";
+}, {
+    readonly value: "-startsAt";
+    readonly label: "Starts Latest";
+}, {
+    readonly value: "title";
+    readonly label: "Title A–Z";
+}, {
+    readonly value: "-stats.totalEntries";
+    readonly label: "Most Entries";
+}];
+export declare const EVENT_SORT_OPTIONS: readonly [{
+    readonly value: "title";
+    readonly label: "Title A–Z";
+}, {
+    readonly value: "-title";
+    readonly label: "Title Z–A";
+}, {
+    readonly value: "-startsAt";
+    readonly label: "Starts Latest";
+}, {
+    readonly value: "startsAt";
+    readonly label: "Starts Soonest";
+}, {
+    readonly value: "-endsAt";
+    readonly label: "Ends Latest";
+}, {
+    readonly value: "endsAt";
+    readonly label: "Ends Soonest";
+}, {
+    readonly value: "-stats.totalEntries";
+    readonly label: "Most Entries";
+}, {
+    readonly value: "-createdAt";
+    readonly label: "Newest First";
+}];
+export declare function getEventFilterKeys(variant: EventFilterVariant): readonly string[];
+export declare function getEventSortOptions(variant: EventFilterVariant): ReadonlyArray<{
+    value: string;
+    label: string;
+}>;
+export interface EventFiltersProps {
+    table: UrlTable;
+    variant?: EventFilterVariant;
+}
+export declare function EventFilters({ table, variant }: EventFiltersProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/events/components/EventFilters.js

@@ -0,0 +1,72 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslations } from "next-intl";
+import { FilterFacetSection } from "../../filters/FilterFacetSection";
+import { RangeFilter } from "../../filters/RangeFilter";
+import { Div } from "../../../ui";
+export const EVENT_FILTER_KEYS = {
+    admin: ["type", "status", "dateFrom", "dateTo"],
+    seller: ["type", "status", "dateFrom", "dateTo"],
+    public: ["type", "status", "dateFrom", "dateTo"],
+};
+export const EVENT_ADMIN_SORT_OPTIONS = [
+    { value: "title", label: "Title A–Z" },
+    { value: "-title", label: "Title Z–A" },
+    { value: "-startsAt", label: "Starts Latest" },
+    { value: "startsAt", label: "Starts Soonest" },
+    { value: "-endsAt", label: "Ends Latest" },
+    { value: "endsAt", label: "Ends Soonest" },
+    { value: "-stats.totalEntries", label: "Most Entries" },
+    { value: "-createdAt", label: "Newest First" },
+];
+export const EVENT_SELLER_SORT_OPTIONS = EVENT_ADMIN_SORT_OPTIONS;
+export const EVENT_PUBLIC_SORT_OPTIONS = [
+    { value: "startsAt", label: "Starts Soonest" },
+    { value: "-startsAt", label: "Starts Latest" },
+    { value: "title", label: "Title A–Z" },
+    { value: "-stats.totalEntries", label: "Most Entries" },
+];
+// Backward-compatible alias.
+export const EVENT_SORT_OPTIONS = EVENT_ADMIN_SORT_OPTIONS;
+export function getEventFilterKeys(variant) {
+    return EVENT_FILTER_KEYS[variant];
+}
+export function getEventSortOptions(variant) {
+    switch (variant) {
+        case "admin":
+            return EVENT_ADMIN_SORT_OPTIONS;
+        case "seller":
+            return EVENT_SELLER_SORT_OPTIONS;
+        case "public":
+            return EVENT_PUBLIC_SORT_OPTIONS;
+        default:
+            return EVENT_PUBLIC_SORT_OPTIONS;
+    }
+}
+export function EventFilters({ table, variant = "admin" }) {
+    const t = useTranslations("filters");
+    const typeOptions = [
+        { value: "sale", label: t("eventTypeSale") },
+        { value: "offer", label: t("eventTypeOffer") },
+        { value: "poll", label: t("eventTypePoll") },
+        { value: "survey", label: t("eventTypeSurvey") },
+        { value: "feedback", label: t("eventTypeFeedback") },
+    ];
+    const adminStatusOptions = [
+        { value: "draft", label: t("eventStatusDraft") },
+        { value: "active", label: t("eventStatusActive") },
+        { value: "paused", label: t("eventStatusPaused") },
+        { value: "ended", label: t("eventStatusEnded") },
+    ];
+    const publicStatusOptions = [
+        { value: "active", label: t("eventStatusActive") },
+        { value: "ended", label: t("eventStatusEnded") },
+    ];
+    const statusOptions = variant === "public" ? publicStatusOptions : adminStatusOptions;
+    const selectedType = table.get("type")
+        ? table.get("type").split("|").filter(Boolean)
+        : [];
+    const selectedStatus = table.get("status")
+        ? table.get("status").split("|").filter(Boolean)
+        : [];
+    return (_jsxs(Div, { children: [_jsx(FilterFacetSection, { title: t("type"), options: typeOptions, selected: selectedType, onChange: (vals) => table.set("type", vals.join("|")), searchable: false, defaultCollapsed: false }), _jsx(FilterFacetSection, { title: t("status"), options: statusOptions, selected: selectedStatus, onChange: (vals) => table.set("status", vals.join("|")), searchable: false, defaultCollapsed: false }), _jsx(RangeFilter, { title: t("dateRange"), type: "date", minValue: table.get("dateFrom"), maxValue: table.get("dateTo"), onMinChange: (v) => table.set("dateFrom", v), onMaxChange: (v) => table.set("dateTo", v), minPlaceholder: t("minDate"), maxPlaceholder: t("maxDate"), defaultCollapsed: true })] }));
+}

package/dist/features/events/components/EventFormDrawer.d.ts

@@ -0,0 +1,22 @@
+import React from "react";
+import type { EventType } from "../types";
+export interface EventFormDrawerProps {
+    isOpen: boolean;
+    onClose: () => void;
+    mode?: "create" | "edit";
+    eventType?: EventType;
+    /** Render the drawer header (title and close button) */
+    renderHeader?: () => React.ReactNode;
+    /** Render the base fields (title, description, dates, cover image) */
+    renderBaseFields?: () => React.ReactNode;
+    /** Render the media fields (cover, gallery, winners, additional) */
+    renderMediaFields?: () => React.ReactNode;
+    /** Render the type-specific config form */
+    renderTypeConfig?: () => React.ReactNode;
+    /** Render the type selector (shown only in create mode) */
+    renderTypeSelector?: () => React.ReactNode;
+    /** Render the footer actions (save/cancel) */
+    renderFooter?: () => React.ReactNode;
+    className?: string;
+}
+export declare function EventFormDrawer({ isOpen, onClose, renderHeader, renderBaseFields, renderMediaFields, renderTypeConfig, renderTypeSelector, renderFooter, className, }: EventFormDrawerProps): import("react/jsx-runtime").JSX.Element | null;

package/dist/features/events/components/EventFormDrawer.js

@@ -0,0 +1,6 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+export function EventFormDrawer({ isOpen, onClose, renderHeader, renderBaseFields, renderMediaFields, renderTypeConfig, renderTypeSelector, renderFooter, className = "", }) {
+    if (!isOpen)
+        return null;
+    return (_jsxs("div", { className: `space-y-6 ${className}`, "data-section": "eventformdrawer-div-278", children: [renderHeader?.(), renderTypeSelector?.(), renderBaseFields?.(), renderMediaFields?.(), renderTypeConfig?.(), renderFooter?.()] }));
+}

package/dist/features/events/components/EventLeaderboard.d.ts

@@ -0,0 +1,23 @@
+import React from "react";
+import type { LeaderboardEntry } from "../types";
+export interface EventLeaderboardProps {
+    isLoading?: boolean;
+    isEmpty?: boolean;
+    /** Render the full ranked list — caller provides entries via hook */
+    renderList?: () => React.ReactNode;
+    /** Render a single row; used when caller wants item-level control */
+    renderEntry?: (entry: LeaderboardEntry, index: number) => React.ReactNode;
+    /** Entries — used only when renderEntry is provided */
+    entries?: LeaderboardEntry[];
+    /** Empty state node */
+    renderEmpty?: () => React.ReactNode;
+    /** Loading spinner / skeleton */
+    renderSkeleton?: () => React.ReactNode;
+    labels?: {
+        title?: string;
+        noEntries?: string;
+        points?: string;
+    };
+    className?: string;
+}
+export declare function EventLeaderboard({ isLoading, isEmpty, renderList, renderEntry, entries, renderEmpty, renderSkeleton, labels, className, }: EventLeaderboardProps): import("react/jsx-runtime").JSX.Element;

package/dist/features/events/components/EventLeaderboard.js

@@ -0,0 +1,18 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import React from "react";
+import { Span, Text } from "../../../ui";
+export function EventLeaderboard({ isLoading = false, isEmpty = false, renderList, renderEntry, entries = [], renderEmpty, renderSkeleton, labels = {}, className = "", }) {
+    if (isLoading) {
+        if (renderSkeleton)
+            return _jsx(_Fragment, { children: renderSkeleton() });
+        return _jsx("div", { className: "flex justify-center py-8", "data-section": "eventleaderboard-div-279", children: "Loading\u2026" });
+    }
+    if (isEmpty) {
+        if (renderEmpty)
+            return _jsx(_Fragment, { children: renderEmpty() });
+        return (_jsx(Text, { variant: "secondary", size: "sm", className: "text-center py-4", children: labels.noEntries ?? "No entries yet." }));
+    }
+    if (renderList)
+        return _jsx("div", { className: className, "data-section": "eventleaderboard-div-280", children: renderList() });
+    return (_jsx("div", { className: `space-y-2 ${className}`, "data-section": "eventleaderboard-div-281", children: entries.map((entry, i) => renderEntry ? (_jsx(React.Fragment, { children: renderEntry(entry, i) }, entry.userId)) : (_jsxs("div", { className: "flex items-center justify-between p-3 rounded-xl border", "data-section": "eventleaderboard-div-282", children: [_jsxs(Span, { className: "font-medium", children: ["#", entry.rank, " ", entry.userDisplayName] }), _jsxs(Span, { children: [entry.points, " ", labels.points ?? "pts"] })] }, entry.userId))) }));
+}

package/dist/features/events/components/EventParticipateView.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+export interface EventParticipateViewProps {
+    isLoading?: boolean;
+    isSubmitted?: boolean;
+    /** Render the event title / summary at the top of the form */
+    renderEventInfo?: () => React.ReactNode;
+    /** Render the participation form fields (survey, poll options, etc.) */
+    renderForm?: () => React.ReactNode;
+    /** Render the submit button / action row */
+    renderAction?: () => React.ReactNode;
+    /** Render the success confirmation after submission */
+    renderSuccess?: () => React.ReactNode;
+    /** Loading skeleton */
+    renderSkeleton?: () => React.ReactNode;
+    /** Redirect/gate when user is not authenticated */
+    renderAuthGate?: () => React.ReactNode;
+    className?: string;
+}
+export declare function EventParticipateView({ isLoading, isSubmitted, renderEventInfo, renderForm, renderAction, renderSuccess, renderSkeleton, renderAuthGate, className, }: EventParticipateViewProps): import("react/jsx-runtime").JSX.Element;