@microcosmmoney/portal-react 3.12.8 → 3.13.0

package/dist/main-portal/contexts/MCCPriceContext.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+export interface MCCTickerData {
+    price: number | null;
+    basePrice: number | null;
+    marketPrice: number | null;
+    cpmmReserves: {
+        mcc: number;
+        usdc: number;
+    } | null;
+    miningVaultMcc: number | null;
+    volume24h: {
+        total: number;
+        buy: number;
+        sell: number;
+    } | null;
+    trades24h: {
+        buys: number;
+        sells: number;
+    } | null;
+    lastTrade: {
+        price: number;
+        amount: number;
+        direction: string;
+        time: number;
+    } | null;
+    updatedAt: string | null;
+    fdv: number | null;
+    miningPrice: number | null;
+}
+interface MCCPriceContextValue extends MCCTickerData {
+    loading: boolean;
+    refresh: () => Promise<void>;
+}
+export declare function MCCPriceProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useMCCPrice(): MCCPriceContextValue;
+export {};

package/dist/main-portal/contexts/MCCPriceContext.js

@@ -0,0 +1,70 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MCCPriceProvider = MCCPriceProvider;
+exports.useMCCPrice = useMCCPrice;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const POLL_INTERVAL = 15000; // 15 seconds
+const MCCPriceContext = (0, react_1.createContext)(null);
+function MCCPriceProvider({ children }) {
+    const [data, setData] = (0, react_1.useState)({
+        price: null, basePrice: null, marketPrice: null,
+        cpmmReserves: null, miningVaultMcc: null,
+        volume24h: null, trades24h: null, lastTrade: null,
+        updatedAt: null, fdv: null, miningPrice: null,
+    });
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const fetchTicker = (0, react_1.useCallback)(async () => {
+        try {
+            const res = await fetch('/api/stats/ticker');
+            if (!res.ok)
+                return;
+            const json = await res.json();
+            if (!json.success || !json.data)
+                return;
+            const d = json.data;
+            const price = d.price ?? null;
+            setData({
+                price,
+                basePrice: d.base_price ?? null,
+                marketPrice: d.market_price ?? null,
+                cpmmReserves: d.cpmm_reserves ?? null,
+                miningVaultMcc: d.mining_vault_mcc ?? null,
+                volume24h: d.volume_24h ?? null,
+                trades24h: d.trades_24h ?? null,
+                lastTrade: d.last_trade ?? null,
+                updatedAt: d.updated_at ?? null,
+                fdv: price ? price * 1000000000 : null,
+                miningPrice: (d.base_price ? d.base_price * 4 : null),
+            });
+        }
+        catch {
+            // Silent — stale data is acceptable
+        }
+        finally {
+            setLoading(false);
+        }
+    }, []);
+    (0, react_1.useEffect)(() => {
+        fetchTicker();
+        const interval = setInterval(fetchTicker, POLL_INTERVAL);
+        return () => clearInterval(interval);
+    }, [fetchTicker]);
+    return ((0, jsx_runtime_1.jsx)(MCCPriceContext.Provider, { value: { ...data, loading, refresh: fetchTicker }, children: children }));
+}
+function useMCCPrice() {
+    const ctx = (0, react_1.useContext)(MCCPriceContext);
+    if (!ctx) {
+        // Return safe defaults when used outside provider (e.g. in static pages)
+        return {
+            price: null, basePrice: null, marketPrice: null,
+            cpmmReserves: null, miningVaultMcc: null,
+            volume24h: null, trades24h: null, lastTrade: null,
+            updatedAt: null, fdv: null, miningPrice: null,
+            loading: true, refresh: async () => { },
+        };
+    }
+    return ctx;
+}

package/dist/main-portal/contexts/WalletContext.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import type { MCCBalance, MCCLockPeriod, MCCMinting, MCCMintingStats, MiningWeight, UserRank, PDABalance, MCDBalance, MCDTransaction, MCDUserDailyReward, TerritoryHoldings, NextLevelRequirement } from '../lib/types/api';
+interface PDAInfo {
+    pda_address: string;
+    token_account: string;
+    bump: number;
+}
+interface WalletContextType {
+    connected: boolean;
+    address: string | null;
+    balance: MCCBalance | null;
+    totalBalance: number;
+    availableBalance: number;
+    lockedBalance: number;
+    pdaBalance: PDABalance | null;
+    pdaInfo: PDAInfo | null;
+    onChainBalance: number;
+    lockPeriods: MCCLockPeriod[];
+    mintingHistory: MCCMinting[];
+    mintingStats: MCCMintingStats | null;
+    mcdBalance: MCDBalance | null;
+    mcdAmount: number;
+    mcdTotalReceived: number;
+    mcdTotalSpent: number;
+    mcdTransactions: MCDTransaction[];
+    mcdDailyRewards: MCDUserDailyReward[];
+    userRank: UserRank | null;
+    currentLevel: number | null;
+    nextRank: UserRank | null;
+    nextLevel: number | null;
+    progressPercent: number;
+    holdings: TerritoryHoldings;
+    nextLevelRequirement: NextLevelRequirement | null;
+    miningWeight: MiningWeight | null;
+    loading: boolean;
+    isRefreshing: boolean;
+    error: string | null;
+    refreshBalance: () => Promise<void>;
+    refreshMinting: () => Promise<void>;
+    refreshRank: () => Promise<void>;
+    refreshPDABalance: () => Promise<void>;
+    refreshMCD: () => Promise<void>;
+}
+export declare const useWallet: () => WalletContextType;
+export declare function WalletProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/main-portal/contexts/WalletContext.js

@@ -0,0 +1,94 @@
+"use strict";
+'use client';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWallet = void 0;
+exports.WalletProvider = WalletProvider;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const useAuth_1 = require("../hooks/useAuth");
+const useMCC_1 = require("../hooks/useMCC");
+const useMCD_1 = require("../hooks/useMCD");
+const useUserRank_1 = require("../hooks/useUserRank");
+const EMPTY_HOLDINGS = { station: 0, matrix: 0, sector: 0, system: 0 };
+const WalletContext = (0, react_1.createContext)({
+    connected: false,
+    address: null,
+    balance: null,
+    totalBalance: 0,
+    availableBalance: 0,
+    lockedBalance: 0,
+    pdaBalance: null,
+    pdaInfo: null,
+    onChainBalance: 0,
+    lockPeriods: [],
+    mintingHistory: [],
+    mintingStats: null,
+    mcdBalance: null,
+    mcdAmount: 0,
+    mcdTotalReceived: 0,
+    mcdTotalSpent: 0,
+    mcdTransactions: [],
+    mcdDailyRewards: [],
+    userRank: null,
+    currentLevel: null,
+    nextRank: null,
+    nextLevel: null,
+    progressPercent: 0,
+    holdings: EMPTY_HOLDINGS,
+    nextLevelRequirement: null,
+    miningWeight: null,
+    loading: true,
+    isRefreshing: false,
+    error: null,
+    refreshBalance: async () => { },
+    refreshMinting: async () => { },
+    refreshRank: async () => { },
+    refreshPDABalance: async () => { },
+    refreshMCD: async () => { },
+});
+const useWallet = () => (0, react_1.useContext)(WalletContext);
+exports.useWallet = useWallet;
+function WalletProvider({ children }) {
+    const { user } = (0, useAuth_1.useAuth)();
+    const mccData = (0, useMCC_1.useMCC)(user?.uid);
+    const mcdData = (0, useMCD_1.useMCD)(user?.uid);
+    const rankData = (0, useUserRank_1.useUserRank)(user?.uid);
+    const loading = mccData.loading || mcdData.loading || rankData.loading;
+    const error = mccData.error || mcdData.error || rankData.error;
+    return ((0, jsx_runtime_1.jsx)(WalletContext.Provider, { value: {
+            connected: !!user,
+            address: user?.uid || null,
+            balance: mccData.balance,
+            totalBalance: mccData.totalBalance,
+            availableBalance: mccData.availableBalance,
+            lockedBalance: mccData.lockedBalance,
+            pdaBalance: mccData.pdaBalance,
+            pdaInfo: mccData.pdaInfo,
+            onChainBalance: mccData.onChainBalance,
+            lockPeriods: mccData.lockPeriods,
+            mintingHistory: mccData.mintingHistory,
+            mintingStats: mccData.mintingStats,
+            mcdBalance: mcdData.balance,
+            mcdAmount: mcdData.mcdBalance,
+            mcdTotalReceived: mcdData.totalReceived,
+            mcdTotalSpent: mcdData.totalSpent,
+            mcdTransactions: mcdData.transactions,
+            mcdDailyRewards: mcdData.dailyRewards,
+            userRank: rankData.rank,
+            currentLevel: rankData.currentLevel,
+            nextRank: rankData.nextRank,
+            nextLevel: rankData.nextLevel,
+            progressPercent: rankData.progressPercent,
+            holdings: rankData.holdings,
+            nextLevelRequirement: rankData.nextLevelRequirement,
+            miningWeight: rankData.miningWeight,
+            loading,
+            isRefreshing: mccData.isRefreshing,
+            error,
+            refreshBalance: mccData.refresh,
+            refreshMinting: mccData.refreshMinting,
+            refreshRank: rankData.refresh,
+            refreshPDABalance: mccData.refreshPDABalance,
+            refreshMCD: mcdData.refresh,
+        }, children: children }));
+}

package/dist/main-portal/hooks/index.d.ts

@@ -0,0 +1,4 @@
+export { useAuth } from './useAuth';
+export { useIsMobile } from './use-mobile';
+export { useMCC } from './useMCC';
+export { useUserRank } from './useUserRank';

package/dist/main-portal/hooks/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserRank = exports.useMCC = exports.useIsMobile = exports.useAuth = void 0;
+var useAuth_1 = require("./useAuth");
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return useAuth_1.useAuth; } });
+var use_mobile_1 = require("./use-mobile");
+Object.defineProperty(exports, "useIsMobile", { enumerable: true, get: function () { return use_mobile_1.useIsMobile; } });
+var useMCC_1 = require("./useMCC");
+Object.defineProperty(exports, "useMCC", { enumerable: true, get: function () { return useMCC_1.useMCC; } });
+var useUserRank_1 = require("./useUserRank");
+Object.defineProperty(exports, "useUserRank", { enumerable: true, get: function () { return useUserRank_1.useUserRank; } });

package/dist/main-portal/hooks/use-breakpoint.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 9-Tier Responsive Breakpoint System
+ * Matches globals.css @theme breakpoint definitions exactly
+ */
+export declare const BREAKPOINTS: {
+    readonly "3xs": 320;
+    readonly "2xs": 360;
+    readonly xs: 475;
+    readonly sm: 640;
+    readonly md: 768;
+    readonly lg: 1024;
+    readonly xl: 1280;
+    readonly "2xl": 1536;
+    readonly "3xl": 1920;
+};
+export type BreakpointKey = keyof typeof BREAKPOINTS;
+/**
+ * Comprehensive breakpoint hook for responsive JS logic.
+ *
+ * Usage:
+ *   const { current, isAbove, isBelow, isBetween, width } = useBreakpoint()
+ *   if (isAbove("md")) { ... }  // >= 768px
+ *   if (isBelow("sm")) { ... }  // < 640px
+ *   if (isBetween("xs", "lg")) { ... }  // >= 475px && < 1024px
+ */
+export declare function useBreakpoint(): {
+    /** Current active breakpoint name */
+    current: "sm" | "md" | "lg" | "base" | "3xs" | "2xs" | "xs" | "xl" | "2xl" | "3xl";
+    /** True if width >= given breakpoint */
+    isAbove: (bp: BreakpointKey) => boolean;
+    /** True if width < given breakpoint */
+    isBelow: (bp: BreakpointKey) => boolean;
+    /** True if width >= min and < max */
+    isBetween: (min: BreakpointKey, max: BreakpointKey) => boolean;
+    /** Raw viewport width in px */
+    width: number;
+    /** False during SSR / before hydration */
+    hasMounted: boolean;
+    /** Legacy compat: true when < md (768px) */
+    isMobile: boolean;
+    /** true when < xs (475px) — small phones */
+    isSmallPhone: boolean;
+    /** true when >= md && < lg — tablets */
+    isTablet: boolean;
+};

package/dist/main-portal/hooks/use-breakpoint.js

@@ -0,0 +1,91 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+"use client";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BREAKPOINTS = void 0;
+exports.useBreakpoint = useBreakpoint;
+const react_1 = require("react");
+/**
+ * 9-Tier Responsive Breakpoint System
+ * Matches globals.css @theme breakpoint definitions exactly
+ */
+exports.BREAKPOINTS = {
+    "3xs": 320,
+    "2xs": 360,
+    xs: 475,
+    sm: 640,
+    md: 768,
+    lg: 1024,
+    xl: 1280,
+    "2xl": 1536,
+    "3xl": 1920,
+};
+const BREAKPOINT_ORDER = [
+    "3xs", "2xs", "xs", "sm", "md", "lg", "xl", "2xl", "3xl",
+];
+/**
+ * Returns the current active breakpoint name based on window width.
+ * Uses min-width (mobile-first): returns the largest breakpoint that fits.
+ * Below 320px returns "base".
+ */
+function getActiveBreakpoint(width) {
+    for (let i = BREAKPOINT_ORDER.length - 1; i >= 0; i--) {
+        if (width >= exports.BREAKPOINTS[BREAKPOINT_ORDER[i]]) {
+            return BREAKPOINT_ORDER[i];
+        }
+    }
+    return "base";
+}
+/**
+ * Comprehensive breakpoint hook for responsive JS logic.
+ *
+ * Usage:
+ *   const { current, isAbove, isBelow, isBetween, width } = useBreakpoint()
+ *   if (isAbove("md")) { ... }  // >= 768px
+ *   if (isBelow("sm")) { ... }  // < 640px
+ *   if (isBetween("xs", "lg")) { ... }  // >= 475px && < 1024px
+ */
+function useBreakpoint() {
+    const [width, setWidth] = (0, react_1.useState)(0);
+    const [hasMounted, setHasMounted] = (0, react_1.useState)(false);
+    (0, react_1.useEffect)(() => {
+        setHasMounted(true);
+        setWidth(window.innerWidth);
+        let rafId;
+        const handleResize = () => {
+            cancelAnimationFrame(rafId);
+            rafId = requestAnimationFrame(() => {
+                setWidth(window.innerWidth);
+            });
+        };
+        window.addEventListener("resize", handleResize);
+        return () => {
+            window.removeEventListener("resize", handleResize);
+            cancelAnimationFrame(rafId);
+        };
+    }, []);
+    const isAbove = (0, react_1.useCallback)((bp) => width >= exports.BREAKPOINTS[bp], [width]);
+    const isBelow = (0, react_1.useCallback)((bp) => width < exports.BREAKPOINTS[bp], [width]);
+    const isBetween = (0, react_1.useCallback)((min, max) => width >= exports.BREAKPOINTS[min] && width < exports.BREAKPOINTS[max], [width]);
+    const current = hasMounted ? getActiveBreakpoint(width) : "md";
+    return {
+        /** Current active breakpoint name */
+        current,
+        /** True if width >= given breakpoint */
+        isAbove,
+        /** True if width < given breakpoint */
+        isBelow,
+        /** True if width >= min and < max */
+        isBetween,
+        /** Raw viewport width in px */
+        width: hasMounted ? width : 0,
+        /** False during SSR / before hydration */
+        hasMounted,
+        /** Legacy compat: true when < md (768px) */
+        isMobile: hasMounted ? width < exports.BREAKPOINTS.md : false,
+        /** true when < xs (475px) — small phones */
+        isSmallPhone: hasMounted ? width < exports.BREAKPOINTS.xs : false,
+        /** true when >= md && < lg — tablets */
+        isTablet: hasMounted ? width >= exports.BREAKPOINTS.md && width < exports.BREAKPOINTS.lg : false,
+    };
+}

package/dist/main-portal/hooks/use-mobile.d.ts

@@ -0,0 +1 @@
+export declare function useIsMobile(): boolean;

package/dist/main-portal/hooks/use-mobile.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsMobile = useIsMobile;
+// AI-generated · AI-managed · AI-maintained
+const React = __importStar(require("react"));
+const use_breakpoint_1 = require("./use-breakpoint");
+const MOBILE_BREAKPOINT = use_breakpoint_1.BREAKPOINTS.md; // 768px
+function useIsMobile() {
+    const [isMobile, setIsMobile] = React.useState(false);
+    const [hasMounted, setHasMounted] = React.useState(false);
+    React.useEffect(() => {
+        setHasMounted(true);
+        const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+        const onChange = () => {
+            setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+        };
+        mql.addEventListener("change", onChange);
+        setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+        return () => mql.removeEventListener("change", onChange);
+    }, []);
+    return hasMounted ? isMobile : false;
+}

package/dist/main-portal/hooks/use-toast.d.ts

@@ -0,0 +1,44 @@
+import * as React from 'react';
+import type { ToastActionElement, ToastProps } from '../components/ui/toast';
+type ToasterToast = ToastProps & {
+    id: string;
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    action?: ToastActionElement;
+};
+declare const actionTypes: {
+    readonly ADD_TOAST: "ADD_TOAST";
+    readonly UPDATE_TOAST: "UPDATE_TOAST";
+    readonly DISMISS_TOAST: "DISMISS_TOAST";
+    readonly REMOVE_TOAST: "REMOVE_TOAST";
+};
+type ActionType = typeof actionTypes;
+type Action = {
+    type: ActionType['ADD_TOAST'];
+    toast: ToasterToast;
+} | {
+    type: ActionType['UPDATE_TOAST'];
+    toast: Partial<ToasterToast>;
+} | {
+    type: ActionType['DISMISS_TOAST'];
+    toastId?: ToasterToast['id'];
+} | {
+    type: ActionType['REMOVE_TOAST'];
+    toastId?: ToasterToast['id'];
+};
+interface State {
+    toasts: ToasterToast[];
+}
+export declare const reducer: (state: State, action: Action) => State;
+type Toast = Omit<ToasterToast, 'id'>;
+declare function toast({ ...props }: Toast): {
+    id: string;
+    dismiss: () => void;
+    update: (props: ToasterToast) => void;
+};
+declare function useToast(): {
+    toast: typeof toast;
+    dismiss: (toastId?: string) => void;
+    toasts: ToasterToast[];
+};
+export { useToast, toast };

package/dist/main-portal/hooks/use-toast.js

@@ -0,0 +1,164 @@
+"use strict";
+// AI-generated · AI-managed · AI-maintained
+'use client';
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reducer = void 0;
+exports.useToast = useToast;
+exports.toast = toast;
+const React = __importStar(require("react"));
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+const actionTypes = {
+    ADD_TOAST: 'ADD_TOAST',
+    UPDATE_TOAST: 'UPDATE_TOAST',
+    DISMISS_TOAST: 'DISMISS_TOAST',
+    REMOVE_TOAST: 'REMOVE_TOAST',
+};
+let count = 0;
+function genId() {
+    count = (count + 1) % Number.MAX_SAFE_INTEGER;
+    return count.toString();
+}
+const toastTimeouts = new Map();
+const addToRemoveQueue = (toastId) => {
+    if (toastTimeouts.has(toastId)) {
+        return;
+    }
+    const timeout = setTimeout(() => {
+        toastTimeouts.delete(toastId);
+        dispatch({
+            type: 'REMOVE_TOAST',
+            toastId: toastId,
+        });
+    }, TOAST_REMOVE_DELAY);
+    toastTimeouts.set(toastId, timeout);
+};
+const reducer = (state, action) => {
+    switch (action.type) {
+        case 'ADD_TOAST':
+            return {
+                ...state,
+                toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+            };
+        case 'UPDATE_TOAST':
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === action.toast.id ? { ...t, ...action.toast } : t),
+            };
+        case 'DISMISS_TOAST': {
+            const { toastId } = action;
+            if (toastId) {
+                addToRemoveQueue(toastId);
+            }
+            else {
+                state.toasts.forEach((toast) => {
+                    addToRemoveQueue(toast.id);
+                });
+            }
+            return {
+                ...state,
+                toasts: state.toasts.map((t) => t.id === toastId || toastId === undefined
+                    ? {
+                        ...t,
+                        open: false,
+                    }
+                    : t),
+            };
+        }
+        case 'REMOVE_TOAST':
+            if (action.toastId === undefined) {
+                return {
+                    ...state,
+                    toasts: [],
+                };
+            }
+            return {
+                ...state,
+                toasts: state.toasts.filter((t) => t.id !== action.toastId),
+            };
+    }
+};
+exports.reducer = reducer;
+const listeners = [];
+let memoryState = { toasts: [] };
+function dispatch(action) {
+    memoryState = (0, exports.reducer)(memoryState, action);
+    listeners.forEach((listener) => {
+        listener(memoryState);
+    });
+}
+function toast({ ...props }) {
+    const id = genId();
+    const update = (props) => dispatch({
+        type: 'UPDATE_TOAST',
+        toast: { ...props, id },
+    });
+    const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id });
+    dispatch({
+        type: 'ADD_TOAST',
+        toast: {
+            ...props,
+            id,
+            open: true,
+            onOpenChange: (open) => {
+                if (!open)
+                    dismiss();
+            },
+        },
+    });
+    return {
+        id: id,
+        dismiss,
+        update,
+    };
+}
+function useToast() {
+    const [state, setState] = React.useState(memoryState);
+    React.useEffect(() => {
+        listeners.push(setState);
+        return () => {
+            const index = listeners.indexOf(setState);
+            if (index > -1) {
+                listeners.splice(index, 1);
+            }
+        };
+    }, [state]);
+    return {
+        ...state,
+        toast,
+        dismiss: (toastId) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+    };
+}