@mohasinac/appkit 4.71.0 → 4.71.2

package/dist/features/collector-drops/hooks/useCollectorDrops.js

@@ -0,0 +1,105 @@
+import { useQuery } from "@tanstack/react-query";
+import { apiClient } from "../../../http/index.js";
+import { isCollectorDropListing } from "../../products/utils/listing-type.js";
+import { COLLECTOR_DROP_ENDPOINTS, BID_ENDPOINTS, PRODUCT_ENDPOINTS } from "../../../constants/api-endpoints.js";
+function toQueryString(params) {
+    if (typeof params === "string") {
+        return params.startsWith("?") ? params.slice(1) : params;
+    }
+    if (params instanceof URLSearchParams) {
+        return params.toString();
+    }
+    const sp = new URLSearchParams();
+    Object.entries(params).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && value !== "") {
+            sp.set(key, String(value));
+        }
+    });
+    return sp.toString();
+}
+export function useCollectorDrops(params = {}, opts) {
+    const endpoint = opts?.endpoint ?? COLLECTOR_DROP_ENDPOINTS.LIST;
+    const queryKeyPrefix = opts?.queryKeyPrefix ?? "collector-drops";
+    const qs = toQueryString(params);
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: [queryKeyPrefix, endpoint, qs],
+        queryFn: () => apiClient.get(`${endpoint}${qs ? `?${qs}` : ""}`),
+        enabled: opts?.enabled ?? true,
+        initialData: opts?.initialData,
+        staleTime: opts?.staleTime ?? (opts?.initialData !== undefined ? Infinity : 0),
+    });
+    return {
+        data,
+        collectorDrops: data?.items ?? [],
+        total: data?.total ?? 0,
+        totalPages: data?.totalPages ?? 1,
+        hasMore: data?.hasMore ?? false,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}
+export function useCollectorDrop(slug, opts) {
+    const { data, isLoading, error, refetch } = useQuery({
+        queryKey: ["collector-drop", slug],
+        queryFn: () => apiClient.get(COLLECTOR_DROP_ENDPOINTS.BY_SLUG(slug)),
+        enabled: (opts?.enabled ?? true) && !!slug,
+    });
+    return {
+        collectorDrop: data ?? null,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+        refetch,
+    };
+}
+export function useCollectorDropBids(collectorDropSlug, limit = 10, opts) {
+    const { data, isLoading, error } = useQuery({
+        queryKey: ["collector-drop-bids", collectorDropSlug, limit],
+        queryFn: () => apiClient.get(`${COLLECTOR_DROP_ENDPOINTS.BIDS(collectorDropSlug)}?limit=${limit}`),
+        enabled: (opts?.enabled ?? true) && !!collectorDropSlug,
+        // 🛑 Do NOT restore a ~15s interval here. Live collector drop state on the detail
+        // page comes from the SSE channel (`useRealtimeBids` -> `useLiveCollectorDropBid`,
+        // consumed by LiveBidPrice / LiveMinIncrement / PlaceBidFormClient), NOT
+        // from this hook — so a fast poll here buys no freshness the page does not
+        // already have, and duplicates a stream that already costs a held-open
+        // function per viewer.
+        //
+        // Verified 2026-09-14: this hook currently has no call sites at all outside
+        // the appkit barrel re-export, so the old 15s interval was billing nothing
+        // only by accident. Kept deliberately slow so that adopting it cannot
+        // silently reintroduce a per-viewer poll.
+        refetchInterval: 60000,
+    });
+    return {
+        bids: data?.items ?? [],
+        total: data?.total ?? 0,
+        isLoading,
+        error: error instanceof Error ? error.message : null,
+    };
+}
+export function useCollectorDropDetail(id, opts) {
+    const enabled = opts?.enabled ?? true;
+    const productEndpoint = opts?.productEndpoint ?? PRODUCT_ENDPOINTS.BY_ID(id);
+    const bidsEndpoint = opts?.bidsEndpoint ?? BID_ENDPOINTS.BY_PRODUCT(id);
+    const productQueryKeyPrefix = opts?.productQueryKeyPrefix ?? "product";
+    const bidsQueryKeyPrefix = opts?.bidsQueryKeyPrefix ?? "bids";
+    const refetchIntervalMs = opts?.refetchIntervalMs ?? 60000;
+    const productQuery = useQuery({
+        queryKey: [productQueryKeyPrefix, id, productEndpoint],
+        queryFn: () => apiClient.get(productEndpoint),
+        enabled: enabled && Boolean(id),
+    });
+    const product = productQuery.data ?? null;
+    const bidsQuery = useQuery({
+        queryKey: [bidsQueryKeyPrefix, id, bidsEndpoint],
+        queryFn: () => apiClient.get(bidsEndpoint),
+        enabled: enabled && isCollectorDropListing(product ?? undefined),
+        refetchInterval: refetchIntervalMs,
+    });
+    return {
+        productQuery,
+        product,
+        bidsQuery,
+        bids: bidsQuery.data ?? [],
+    };
+}

package/dist/features/collector-drops/hooks/useIsCollectorDropEnded.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Has this collector drop ended, decided on the CLIENT from its end timestamp.
+ *
+ * ## Why this exists
+ *
+ * `CollectorDropDetailPageView` computed `const isEnded = endDate < new Date()` on the
+ * SERVER and froze the answer into eleven places — the status badge, the Buy-Now
+ * chip, the SSE `enabled` flag, the Place-Bid button, the mobile bid card and
+ * the bottom action bar. That is correct only for as long as the rendered HTML
+ * is fresh.
+ *
+ * The page is cached. At `revalidate = 30` the window was small enough to hide
+ * the problem; it is not small enough to be *correct*, and raising the TTL (so
+ * that 95 collector drop pages stop regenerating up to 2,880 times a day each, which is
+ * what produced 3.1M ISR writes) makes it plainly visible: a page cached while
+ * the collector drop was live renders a green **Active** badge and an enabled "Place a
+ * bid" button on a lot that closed hours ago.
+ *
+ * The timestamp needed to know better was already being passed down — it was
+ * used for display only.
+ *
+ * ## What this does NOT change
+ *
+ * Server-side enforcement is independent and already correct: `placeBid` and
+ * `buyNowCollectorDrop` both re-read the product and reject on `endDate < now`, and
+ * `assertCollectorDropActive()` is a third copy. A stale page could never actually
+ * place a bid — the defect was always a misleading affordance, never a bad
+ * write. That is what makes this safe to adopt incrementally: every component
+ * converted is an improvement, and an unconverted one is no worse than today.
+ *
+ * ## Behaviour
+ *
+ * - Starts from `initial` (the server's answer) so the first paint is unchanged
+ *   and hydration does not mismatch.
+ * - Re-checks on mount, which is where a cached page corrects itself.
+ * - Schedules ONE timer for the exact moment of expiry rather than ticking every
+ *   second — a bid button does not need per-second resolution, and an interval
+ *   on every collector drop card would be a needless wakeup. Long waits are clamped to
+ *   the setTimeout 32-bit ceiling and re-armed.
+ */
+export declare function useIsCollectorDropEnded(collectorDropEndDate: Date | string | null | undefined, initial?: boolean): boolean;

package/dist/features/collector-drops/hooks/useIsCollectorDropEnded.js

@@ -0,0 +1,76 @@
+"use client";
+import { useEffect, useState } from "react";
+/**
+ * Has this collector drop ended, decided on the CLIENT from its end timestamp.
+ *
+ * ## Why this exists
+ *
+ * `CollectorDropDetailPageView` computed `const isEnded = endDate < new Date()` on the
+ * SERVER and froze the answer into eleven places — the status badge, the Buy-Now
+ * chip, the SSE `enabled` flag, the Place-Bid button, the mobile bid card and
+ * the bottom action bar. That is correct only for as long as the rendered HTML
+ * is fresh.
+ *
+ * The page is cached. At `revalidate = 30` the window was small enough to hide
+ * the problem; it is not small enough to be *correct*, and raising the TTL (so
+ * that 95 collector drop pages stop regenerating up to 2,880 times a day each, which is
+ * what produced 3.1M ISR writes) makes it plainly visible: a page cached while
+ * the collector drop was live renders a green **Active** badge and an enabled "Place a
+ * bid" button on a lot that closed hours ago.
+ *
+ * The timestamp needed to know better was already being passed down — it was
+ * used for display only.
+ *
+ * ## What this does NOT change
+ *
+ * Server-side enforcement is independent and already correct: `placeBid` and
+ * `buyNowCollectorDrop` both re-read the product and reject on `endDate < now`, and
+ * `assertCollectorDropActive()` is a third copy. A stale page could never actually
+ * place a bid — the defect was always a misleading affordance, never a bad
+ * write. That is what makes this safe to adopt incrementally: every component
+ * converted is an improvement, and an unconverted one is no worse than today.
+ *
+ * ## Behaviour
+ *
+ * - Starts from `initial` (the server's answer) so the first paint is unchanged
+ *   and hydration does not mismatch.
+ * - Re-checks on mount, which is where a cached page corrects itself.
+ * - Schedules ONE timer for the exact moment of expiry rather than ticking every
+ *   second — a bid button does not need per-second resolution, and an interval
+ *   on every collector drop card would be a needless wakeup. Long waits are clamped to
+ *   the setTimeout 32-bit ceiling and re-armed.
+ */
+export function useIsCollectorDropEnded(collectorDropEndDate, initial = false) {
+    const endMs = toMs(collectorDropEndDate);
+    const [ended, setEnded] = useState(initial);
+    useEffect(() => {
+        if (endMs === null) {
+            // No end date — the server's answer is the only one available.
+            setEnded(initial);
+            return;
+        }
+        let timer;
+        const evaluate = () => {
+            const remaining = endMs - Date.now();
+            if (remaining <= 0) {
+                setEnded(true);
+                return;
+            }
+            setEnded(false);
+            // setTimeout overflows past ~24.8 days and fires immediately; re-arm.
+            timer = setTimeout(evaluate, Math.min(remaining, 2147483000));
+        };
+        evaluate();
+        return () => {
+            if (timer)
+                clearTimeout(timer);
+        };
+    }, [endMs, initial]);
+    return ended;
+}
+function toMs(value) {
+    if (!value)
+        return null;
+    const ms = value instanceof Date ? value.getTime() : new Date(value).getTime();
+    return Number.isFinite(ms) ? ms : null;
+}

package/dist/features/collector-drops/hooks/useLiveCollectorDropBid.d.ts

@@ -0,0 +1,20 @@
+export interface UseLiveCollectorDropBidResult {
+    currentBid: number;
+    bidCount: number;
+    /** True once the SSE channel has delivered at least one live update. */
+    isLive: boolean;
+}
+/**
+ * useLiveCollectorDropBid
+ *
+ * Layers the SSE-driven `useRealtimeBids` channel on top of the collector drop
+ * detail page's SSR-rendered `currentBid`/`bidCount` (server props, frozen
+ * at request time / the page's ISR window). Falls back to those SSR values
+ * until the live channel connects and pushes its first update — this is
+ * what lets any viewer watching a collector drop see a new bid the instant
+ * another user places it, mirroring how the cart/wishlist badges layer a
+ * live delta on top of the last known server count.
+ */
+export declare function useLiveCollectorDropBid(productId: string, ssrCurrentBid: number, ssrBidCount: number, opts?: {
+    enabled?: boolean;
+}): UseLiveCollectorDropBidResult;

package/dist/features/collector-drops/hooks/useLiveCollectorDropBid.js

@@ -0,0 +1,23 @@
+"use client";
+import { useRealtimeBids } from "./useRealtimeBids.js";
+/**
+ * useLiveCollectorDropBid
+ *
+ * Layers the SSE-driven `useRealtimeBids` channel on top of the collector drop
+ * detail page's SSR-rendered `currentBid`/`bidCount` (server props, frozen
+ * at request time / the page's ISR window). Falls back to those SSR values
+ * until the live channel connects and pushes its first update — this is
+ * what lets any viewer watching a collector drop see a new bid the instant
+ * another user places it, mirroring how the cart/wishlist badges layer a
+ * live delta on top of the last known server count.
+ */
+export function useLiveCollectorDropBid(productId, ssrCurrentBid, ssrBidCount, opts) {
+    const enabled = opts?.enabled !== false;
+    const live = useRealtimeBids(enabled ? productId : null);
+    const isLive = live.connected && live.currentBid !== null;
+    return {
+        currentBid: isLive ? live.currentBid : ssrCurrentBid,
+        bidCount: isLive && live.bidCount !== null ? live.bidCount : ssrBidCount,
+        isLive,
+    };
+}

package/dist/features/collector-drops/hooks/usePlaceBid.d.ts

@@ -0,0 +1,25 @@
+import type { JsonValue } from "../../../schemas/types";
+export interface BidResult {
+    id: string;
+    productId: string;
+    bidAmount: number;
+    isWinning: boolean;
+    currency: string;
+    [key: string]: JsonValue;
+}
+export interface PlaceBidPayload {
+    productId: string;
+    bidAmount: number;
+}
+/**
+ * usePlaceBid
+ *
+ * Mutation hook for placing a bid on a collector drop product.
+ * Invalidates bid list and collector drop detail queries on success so the UI
+ * reflects the new highest bid without a manual reload.
+ *
+ * @example
+ * const { mutateAsync, isPending } = usePlaceBid();
+ * const bid = await mutateAsync({ productId, bidAmount: amount });
+ */
+export declare function usePlaceBid(): import("@tanstack/react-query").UseMutationResult<BidResult, Error, PlaceBidPayload, unknown>;

package/dist/features/collector-drops/hooks/usePlaceBid.js

@@ -0,0 +1,28 @@
+import { useMutation, useQueryClient } from "@tanstack/react-query";
+import { apiClient } from "../../../http/index.js";
+import { BID_ENDPOINTS } from "../../../constants/api-endpoints.js";
+/**
+ * usePlaceBid
+ *
+ * Mutation hook for placing a bid on a collector drop product.
+ * Invalidates bid list and collector drop detail queries on success so the UI
+ * reflects the new highest bid without a manual reload.
+ *
+ * @example
+ * const { mutateAsync, isPending } = usePlaceBid();
+ * const bid = await mutateAsync({ productId, bidAmount: amount });
+ */
+export function usePlaceBid() {
+    const queryClient = useQueryClient();
+    return useMutation({
+        mutationFn: async (data) => {
+            const result = await apiClient.post(BID_ENDPOINTS.LIST, data);
+            return result.bid;
+        },
+        onSuccess: async (_, { productId }) => {
+            await queryClient.invalidateQueries({ queryKey: ["bids", productId] });
+            await queryClient.invalidateQueries({ queryKey: ["collector-drop", productId] });
+            await queryClient.invalidateQueries({ queryKey: ["product", productId] });
+        },
+    });
+}

package/dist/features/collector-drops/hooks/useRealtimeBids.d.ts

@@ -0,0 +1,41 @@
+export interface RealtimeBidData {
+    currentBid: number;
+    bidCount: number;
+    lastBid: {
+        amount: number;
+        bidderName: string;
+        timestamp: number;
+    } | null;
+    updatedAt: number;
+}
+export interface UseRealtimeBidsReturn {
+    /** Current highest bid — most recent value pushed from the server */
+    currentBid: number | null;
+    /** Total active bid count */
+    bidCount: number | null;
+    /** Info about the most recent bid placed */
+    lastBid: RealtimeBidData["lastBid"];
+    /** Whether the SSE connection is live */
+    connected: boolean;
+    /** Last time the data was updated (epoch ms) */
+    updatedAt: number | null;
+}
+/**
+ * useRealtimeBids
+ *
+ * Subscribes to live collector drop bid updates via Server-Sent Events (SSE).
+ *
+ * Uses a streaming route that keeps a server-side listener open and pushes
+ * updates to the browser via text/event-stream. No Firebase client SDK required.
+ *
+ * Multiple instances pointed at the same URL share ONE underlying connection —
+ * see the `channels` map above for why that matters.
+ *
+ * @param productId - The collector drop product ID to subscribe to, or null to disable
+ * @param getEndpoint - Optional: override the SSE endpoint URL builder.
+ *   Defaults to `/api/realtime/bids/{productId}`.
+ *
+ * @example
+ * const { currentBid, bidCount, connected } = useRealtimeBids(productId);
+ */
+export declare function useRealtimeBids(productId: string | null, getEndpoint?: (id: string) => string): UseRealtimeBidsReturn;

package/dist/features/collector-drops/hooks/useRealtimeBids.js

@@ -0,0 +1,170 @@
+"use client";
+import { normalizeError } from "../../../errors/normalize.js";
+import { useEffect, useState } from "react";
+import { logger } from "../../../core/Logger.js";
+import { BID_ENDPOINTS } from "../../../constants/api-endpoints.js";
+/**
+ * One EventSource per SSE URL, shared by every hook instance that asks for it.
+ *
+ * 🛑 THIS SHARING IS LOAD-BEARING, NOT AN OPTIMISATION.
+ *
+ * `/api/realtime/bids/[id]` holds a serverless invocation open for its full
+ * 45s TTL per connection (route `maxDuration = 50`, `STREAM_TTL_MS = 45_000`),
+ * then self-closes so the browser reconnects. So a connection is not a cheap
+ * socket — it is a continuously-billed function.
+ *
+ * This hook is consumed by `useLiveCollectorDropBid`, which `LiveBidPrice`,
+ * `LiveMinIncrement` and `PlaceBidFormClient` each call independently — and
+ * `CollectorDropDetailPageView` mounts those five times over. Before this map, one
+ * collector drop page view opened FIVE concurrent EventSources to the same URL and
+ * therefore pinned five held-open functions, all pushing byte-identical data.
+ * That was a material share of the Fluid Active CPU that paused the Vercel
+ * account (2026-09-14).
+ *
+ * Keyed on the resolved URL rather than on productId: `getEndpoint` is an
+ * override, and two callers pointing at different endpoints for the same
+ * product must not be handed each other's stream.
+ */
+const channels = new Map();
+/**
+ * Grace period before a zero-ref channel is actually closed.
+ *
+ * Without it, any remount — a React StrictMode double-invoke in dev, a tab
+ * switch inside the page, a re-render that swaps the subtree — tears the
+ * stream down and immediately builds a new one, which costs a fresh function
+ * invocation each time. The route's own header comment records that an
+ * uncontrolled reconnect loop is exactly the failure this endpoint has already
+ * had once.
+ */
+const CHANNEL_CLOSE_GRACE_MS = 1000;
+function notify(channel) {
+    const snapshot = {
+        data: channel.data,
+        connected: channel.connected,
+    };
+    for (const subscriber of channel.subscribers)
+        subscriber(snapshot);
+}
+function openChannel(url) {
+    const es = new EventSource(url);
+    const channel = {
+        es,
+        refCount: 0,
+        subscribers: new Set(),
+        closeTimer: null,
+        data: null,
+        connected: false,
+    };
+    es.onmessage = (event) => {
+        try {
+            const msg = JSON.parse(event.data);
+            if (msg.type === "connected") {
+                channel.connected = true;
+            }
+            else if (msg.type === "update") {
+                channel.data = msg.data ?? null;
+                channel.connected = true;
+            }
+            else if (msg.type === "error") {
+                channel.connected = false;
+            }
+            else {
+                return;
+            }
+            notify(channel);
+        }
+        catch (_err) {
+            void normalizeError(_err);
+            logger.warn("[useRealtimeBids] Failed to parse SSE message");
+        }
+    };
+    es.onerror = () => {
+        // EventSource reconnects on its own, including after the route's
+        // deliberate 45s self-close. Report disconnected; do NOT close here, or
+        // the built-in reconnect is lost and the stream dies permanently.
+        channel.connected = false;
+        notify(channel);
+        logger.warn("[useRealtimeBids] SSE connection error — will retry");
+    };
+    return channel;
+}
+function subscribe(url, onState) {
+    let channel = channels.get(url);
+    if (!channel) {
+        channel = openChannel(url);
+        channels.set(url, channel);
+    }
+    if (channel.closeTimer) {
+        clearTimeout(channel.closeTimer);
+        channel.closeTimer = null;
+    }
+    channel.refCount += 1;
+    channel.subscribers.add(onState);
+    // Hand the newcomer whatever the channel already knows, so a component that
+    // mounts mid-stream renders the live value immediately instead of showing
+    // its SSR fallback until the next push (which may be a whole bid away).
+    onState({ data: channel.data, connected: channel.connected });
+    return () => {
+        const active = channels.get(url);
+        if (!active)
+            return;
+        active.subscribers.delete(onState);
+        active.refCount -= 1;
+        if (active.refCount > 0)
+            return;
+        active.closeTimer = setTimeout(() => {
+            // Re-read: a new subscriber may have arrived during the grace window,
+            // in which case the entry in the map is live again and must survive.
+            const current = channels.get(url);
+            if (!current || current.refCount > 0)
+                return;
+            current.es.close();
+            channels.delete(url);
+        }, CHANNEL_CLOSE_GRACE_MS);
+    };
+}
+/**
+ * useRealtimeBids
+ *
+ * Subscribes to live collector drop bid updates via Server-Sent Events (SSE).
+ *
+ * Uses a streaming route that keeps a server-side listener open and pushes
+ * updates to the browser via text/event-stream. No Firebase client SDK required.
+ *
+ * Multiple instances pointed at the same URL share ONE underlying connection —
+ * see the `channels` map above for why that matters.
+ *
+ * @param productId - The collector drop product ID to subscribe to, or null to disable
+ * @param getEndpoint - Optional: override the SSE endpoint URL builder.
+ *   Defaults to `/api/realtime/bids/{productId}`.
+ *
+ * @example
+ * const { currentBid, bidCount, connected } = useRealtimeBids(productId);
+ */
+export function useRealtimeBids(productId, getEndpoint = BID_ENDPOINTS.REALTIME) {
+    const [state, setState] = useState({
+        data: null,
+        connected: false,
+    });
+    useEffect(() => {
+        if (!productId || typeof EventSource === "undefined") {
+            setState({ data: null, connected: false });
+            return;
+        }
+        const unsubscribe = subscribe(getEndpoint(productId), setState);
+        return () => {
+            unsubscribe();
+            setState((prev) => ({ ...prev, connected: false }));
+        };
+        // `getEndpoint` is deliberately excluded: callers pass an inline arrow in
+        // several places, so including it would resubscribe on every render.
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [productId]);
+    return {
+        currentBid: state.data?.currentBid ?? null,
+        bidCount: state.data?.bidCount ?? null,
+        lastBid: state.data?.lastBid ?? null,
+        connected: state.connected,
+        updatedAt: state.data?.updatedAt ?? null,
+    };
+}

package/dist/features/collector-drops/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./schemas";
+export * from "./columns";
+export * from "./types";
+export * from "./hooks/useCollectorDrops";
+export * from "./hooks/usePlaceBid";
+export * from "./hooks/useRealtimeBids";
+export * from "./components";
+export { manifest } from "./manifest";

package/dist/features/collector-drops/index.js

@@ -0,0 +1,8 @@
+export * from "./schemas/index.js";
+export * from "./columns/index.js";
+export * from "./types/index.js";
+export * from "./hooks/useCollectorDrops.js";
+export * from "./hooks/usePlaceBid.js";
+export * from "./hooks/useRealtimeBids.js";
+export * from "./components/index.js";
+export { manifest } from "./manifest.js";

package/dist/features/collector-drops/manifest.js

@@ -0,0 +1,17 @@
+export const manifest = {
+    name: "collectorDrops",
+    i18nNamespace: "collectorDrops",
+    envKeys: [],
+    routes: [
+        { segment: "[locale]/collector-drops", exports: { default: "CollectorDropsListView" } },
+        {
+            segment: "[locale]/collector-drops/[slug]",
+            exports: { default: "CollectorDropDetailView" },
+        },
+    ],
+    apiRoutes: [
+        { segment: "api/collector-drops", methods: ["GET"] },
+        { segment: "api/collector-drops/[slug]", methods: ["GET"] },
+        { segment: "api/collector-drops/[slug]/bid", methods: ["POST"] },
+    ],
+};

package/dist/features/collector-drops/messages/en.json

@@ -0,0 +1,18 @@
+{
+  "card": {
+    "currentBid": "Current bid",
+    "startingBid": "Starting bid",
+    "bids": "bids",
+    "placeBid": "Place Bid",
+    "ended": "Collector Drop ended"
+  },
+  "countdown": {
+    "hours": "h",
+    "mins": "m",
+    "secs": "s"
+  },
+  "list": {
+    "title": "Live Collector Drops",
+    "empty": "No collector drops running right now."
+  }
+}