@microcosmmoney/auth-react 1.0.0

package/dist/callback.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface AuthCallbackProps {
+    redirectTo?: string;
+    onSuccess?: (user: unknown) => void;
+    onError?: (error: Error) => void;
+    loadingComponent?: React.ReactNode;
+    errorComponent?: (error: Error) => React.ReactNode;
+}
+export declare function AuthCallback({ redirectTo, onSuccess, onError, loadingComponent, errorComponent, }: AuthCallbackProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/callback.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthCallback = AuthCallback;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("./provider");
+function AuthCallback({ redirectTo = '/dashboard', onSuccess, onError, loadingComponent, errorComponent, }) {
+    const { client } = (0, provider_1.useAuth)();
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        let cancelled = false;
+        const handleCallback = async () => {
+            try {
+                const user = await client.handleCallback();
+                if (cancelled)
+                    return;
+                onSuccess?.(user);
+                window.location.href = redirectTo;
+            }
+            catch (err) {
+                if (cancelled)
+                    return;
+                const error = err instanceof Error ? err : new Error('Unknown error');
+                setError(error);
+                onError?.(error);
+            }
+        };
+        handleCallback();
+        return () => {
+            cancelled = true;
+        };
+    }, []);
+    if (error) {
+        if (errorComponent) {
+            return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: errorComponent(error) });
+        }
+        return ((0, jsx_runtime_1.jsxs)("div", { style: { padding: 40, textAlign: 'center', fontFamily: 'monospace' }, children: [(0, jsx_runtime_1.jsx)("h2", { style: { color: '#ef4444', marginBottom: 8 }, children: "Login Failed" }), (0, jsx_runtime_1.jsx)("p", { style: { color: '#71717a', marginBottom: 16 }, children: error.message }), (0, jsx_runtime_1.jsx)("button", { onClick: () => (window.location.href = '/'), style: {
+                        padding: '8px 16px',
+                        border: '1px solid #3f3f46',
+                        borderRadius: 4,
+                        background: 'transparent',
+                        color: '#a1a1aa',
+                        cursor: 'pointer',
+                        fontFamily: 'monospace',
+                    }, children: "Back to Home" })] }));
+    }
+    if (loadingComponent) {
+        return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: loadingComponent });
+    }
+    return ((0, jsx_runtime_1.jsxs)("div", { style: { padding: 40, textAlign: 'center', fontFamily: 'monospace' }, children: [(0, jsx_runtime_1.jsx)("div", { style: {
+                    width: 32,
+                    height: 32,
+                    border: '2px solid #6366f1',
+                    borderTopColor: 'transparent',
+                    borderRadius: '50%',
+                    animation: 'mc-spin 1s linear infinite',
+                    margin: '0 auto 16px',
+                } }), (0, jsx_runtime_1.jsx)("p", { style: { color: '#71717a' }, children: "Processing login..." }), (0, jsx_runtime_1.jsx)("style", { children: `@keyframes mc-spin { to { transform: rotate(360deg) } }` })] }));
+}

package/dist/hooks/use-api-query.d.ts

@@ -0,0 +1,14 @@
+interface UseApiQueryOptions {
+    path: string;
+    requireAuth?: boolean;
+    refetchInterval?: number;
+    skip?: boolean;
+}
+export interface UseApiQueryResult<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+export declare function useApiQuery<T = any>(options: UseApiQueryOptions): UseApiQueryResult<T>;
+export {};

package/dist/hooks/use-api-query.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useApiQuery = useApiQuery;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useApiQuery(options) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const shouldSkip = options.skip || (options.requireAuth && !isAuthenticated);
+    const fetchData = (0, react_1.useCallback)(async () => {
+        if (shouldSkip) {
+            setData(null);
+            setLoading(false);
+            return;
+        }
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const res = await api.get(options.path);
+            if (mountedRef.current) {
+                setData(res.data);
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, options.path, shouldSkip]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        const interval = options.refetchInterval;
+        if (interval && interval > 0 && !shouldSkip) {
+            const timer = setInterval(fetchData, interval);
+            return () => { mountedRef.current = false; clearInterval(timer); };
+        }
+        return () => { mountedRef.current = false; };
+    }, [fetchData, options.refetchInterval, shouldSkip]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-auctions.d.ts

@@ -0,0 +1,3 @@
+export declare function useAuctions(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-auctions.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAuctions = useAuctions;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useAuctions(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/auction-solana/active',
+        refetchInterval: options?.refetchInterval ?? 60000,
+    });
+}

package/dist/hooks/use-dashboard-summary.d.ts

@@ -0,0 +1,23 @@
+interface DashboardSummary {
+    market: {
+        price_usd: number;
+        price_change_24h: number;
+        volume_24h: number;
+        liquidity_usd: number;
+        fdv: number;
+        market_cap: number;
+    } | null;
+    user: {
+        level: any;
+        mcc_balance: any;
+    } | null;
+}
+export declare function useDashboardSummary(wallet?: string, options?: {
+    refetchInterval?: number;
+}): {
+    data: DashboardSummary | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+};
+export {};

package/dist/hooks/use-dashboard-summary.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDashboardSummary = useDashboardSummary;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useDashboardSummary(wallet, options) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [data, setData] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const mountedRef = (0, react_1.useRef)(true);
+    const fetchData = (0, react_1.useCallback)(async () => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const promises = [
+                api.get('/dashboard/market').catch(() => null),
+            ];
+            if (wallet) {
+                promises.push(api.get(`/dashboard/user/${wallet}`).catch(() => null));
+            }
+            const [marketRes, userRes] = await Promise.all(promises);
+            if (mountedRef.current) {
+                setData({
+                    market: marketRes?.data ?? null,
+                    user: userRes?.data ?? null,
+                });
+                setError(null);
+            }
+        }
+        catch (err) {
+            if (mountedRef.current) {
+                setError(err instanceof Error ? err : new Error(String(err)));
+            }
+        }
+        finally {
+            if (mountedRef.current)
+                setLoading(false);
+        }
+    }, [client, wallet]);
+    (0, react_1.useEffect)(() => {
+        mountedRef.current = true;
+        fetchData();
+        const interval = options?.refetchInterval ?? 120000;
+        if (interval > 0) {
+            const timer = setInterval(fetchData, interval);
+            return () => { mountedRef.current = false; clearInterval(timer); };
+        }
+        return () => { mountedRef.current = false; };
+    }, [fetchData, options?.refetchInterval]);
+    return { data, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-mcc-price.d.ts

@@ -0,0 +1,12 @@
+interface MCCPriceData {
+    price: number;
+    price_change_24h?: number;
+    volume_24h?: number;
+    market_cap?: number;
+    source: string;
+    updated_at: string;
+}
+export declare function useMCCPrice(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<MCCPriceData>;
+export {};

package/dist/hooks/use-mcc-price.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCCPrice = useMCCPrice;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMCCPrice(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/mcc/price',
+        refetchInterval: options?.refetchInterval ?? 30000,
+    });
+}

package/dist/hooks/use-mcc-stats.d.ts

@@ -0,0 +1,3 @@
+export declare function useMCCStats(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-mcc-stats.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCCStats = useMCCStats;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMCCStats(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/mcc/stats',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-mcc.d.ts

@@ -0,0 +1,10 @@
+import { MCCBalance, MCCPrice } from '@microcosmmoney/auth-core';
+interface UseMCCResult {
+    balance: MCCBalance | null;
+    price: MCCPrice | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+export declare function useMCC(refreshInterval?: number): UseMCCResult;
+export {};

package/dist/hooks/use-mcc.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCC = useMCC;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMCC(refreshInterval) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [balance, setBalance] = (0, react_1.useState)(null);
+    const [price, setPrice] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const fetchData = (0, react_1.useCallback)(async () => {
+        const api = client.getApiClient();
+        try {
+            setLoading(true);
+            const pricePromise = api.get('/mcc/price')
+                .then(res => setPrice(res.data))
+                .catch(() => { });
+            if (isAuthenticated) {
+                const balancePromise = api.get('/mcc/balance')
+                    .then(res => setBalance(res.data))
+                    .catch(() => { });
+                await Promise.all([pricePromise, balancePromise]);
+            }
+            else {
+                await pricePromise;
+                setBalance(null);
+            }
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Failed to fetch MCC data'));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, isAuthenticated]);
+    (0, react_1.useEffect)(() => {
+        fetchData();
+        if (refreshInterval && refreshInterval > 0) {
+            const timer = setInterval(fetchData, refreshInterval);
+            return () => clearInterval(timer);
+        }
+    }, [fetchData, refreshInterval]);
+    return { balance, price, loading, error, refresh: fetchData };
+}

package/dist/hooks/use-mcd-stats.d.ts

@@ -0,0 +1,3 @@
+export declare function useMCDStats(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-mcd-stats.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCDStats = useMCDStats;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMCDStats(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/mcd/stats',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-mcd.d.ts

@@ -0,0 +1,9 @@
+import { MCDBalance } from '@microcosmmoney/auth-core';
+interface UseMCDResult {
+    balance: MCDBalance | null;
+    loading: boolean;
+    error: Error | null;
+    refresh: () => Promise<void>;
+}
+export declare function useMCD(refreshInterval?: number): UseMCDResult;
+export {};

package/dist/hooks/use-mcd.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMCD = useMCD;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useMCD(refreshInterval) {
+    const { client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [balance, setBalance] = (0, react_1.useState)(null);
+    const [loading, setLoading] = (0, react_1.useState)(true);
+    const [error, setError] = (0, react_1.useState)(null);
+    const fetchBalance = (0, react_1.useCallback)(async () => {
+        if (!isAuthenticated) {
+            setBalance(null);
+            setLoading(false);
+            return;
+        }
+        try {
+            setLoading(true);
+            const api = client.getApiClient();
+            const data = await api.get('/mcd/balance');
+            setBalance(data.data?.attributes || null);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Failed to fetch MCD balance'));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, isAuthenticated]);
+    (0, react_1.useEffect)(() => {
+        fetchBalance();
+        if (refreshInterval && refreshInterval > 0) {
+            const timer = setInterval(fetchBalance, refreshInterval);
+            return () => clearInterval(timer);
+        }
+    }, [fetchBalance, refreshInterval]);
+    return { balance, loading, error, refresh: fetchBalance };
+}

package/dist/hooks/use-mining-records.d.ts

@@ -0,0 +1,4 @@
+export declare function useMiningRecords(options?: {
+    limit?: number;
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-mining-records.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningRecords = useMiningRecords;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMiningRecords(options) {
+    const limit = options?.limit ?? 20;
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/mining/records?limit=${limit}`,
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 0,
+    });
+}

package/dist/hooks/use-mining-stats.d.ts

@@ -0,0 +1,3 @@
+export declare function useMiningStats(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-mining-stats.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useMiningStats = useMiningStats;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useMiningStats(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/mining/stats',
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/hooks/use-organizations.d.ts

@@ -0,0 +1,3 @@
+export declare function useOrganizations(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-organizations.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOrganizations = useOrganizations;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useOrganizations(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/organizations',
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/hooks/use-price-history.d.ts

@@ -0,0 +1,5 @@
+type TimeRange = '1D' | '7D' | '30D';
+export declare function usePriceHistory(range?: TimeRange, options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;
+export {};

package/dist/hooks/use-price-history.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePriceHistory = usePriceHistory;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function usePriceHistory(range = '7D', options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/mcc/price/history?range=${range}`,
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-profile.d.ts

@@ -0,0 +1,13 @@
+import { User } from '@microcosmmoney/auth-core';
+interface UseProfileResult {
+    profile: User | null;
+    loading: boolean;
+    error: Error | null;
+    updateProfile: (data: {
+        display_name?: string;
+    }) => Promise<void>;
+    uploadAvatar: (file: File) => Promise<string | null>;
+    refresh: () => Promise<void>;
+}
+export declare function useProfile(): UseProfileResult;
+export {};

package/dist/hooks/use-profile.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useProfile = useProfile;
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const provider_1 = require("../provider");
+function useProfile() {
+    const { user, client, isAuthenticated } = (0, provider_1.useAuth)();
+    const [profile, setProfile] = (0, react_1.useState)(user);
+    const [loading, setLoading] = (0, react_1.useState)(false);
+    const [error, setError] = (0, react_1.useState)(null);
+    (0, react_1.useEffect)(() => {
+        setProfile(user);
+    }, [user]);
+    const refresh = (0, react_1.useCallback)(async () => {
+        if (!isAuthenticated)
+            return;
+        try {
+            setLoading(true);
+            const api = client.getApiClient();
+            const data = await api.get('/users/me/profile');
+            const raw = data.user || data;
+            const updated = {
+                uid: raw.uid || profile?.uid || '',
+                email: raw.email || profile?.email || '',
+                displayName: raw.display_name || null,
+                avatarUrl: raw.avatar_url || null,
+                role: raw.role || 'user',
+                level: raw.level,
+                title: raw.title,
+                stationId: raw.station_id || null,
+            };
+            setProfile(updated);
+            client.setUser(updated);
+            setError(null);
+        }
+        catch (err) {
+            setError(err instanceof Error ? err : new Error('Failed to fetch profile'));
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, isAuthenticated, profile]);
+    const updateProfile = (0, react_1.useCallback)(async (data) => {
+        if (!isAuthenticated)
+            throw new Error('Not authenticated');
+        try {
+            setLoading(true);
+            const api = client.getApiClient();
+            await api.patch('/users/me/profile', data);
+            if (profile && data.display_name !== undefined) {
+                const updated = { ...profile, displayName: data.display_name };
+                setProfile(updated);
+                client.setUser(updated);
+            }
+            setError(null);
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to update profile');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, isAuthenticated, profile]);
+    const uploadAvatar = (0, react_1.useCallback)(async (file) => {
+        if (!isAuthenticated)
+            throw new Error('Not authenticated');
+        try {
+            setLoading(true);
+            const token = await client.getAccessToken();
+            const formData = new FormData();
+            formData.append('avatar', file);
+            const response = await fetch('https://api.microcosm.money/v1/users/me/avatar', {
+                method: 'POST',
+                headers: { Authorization: `Bearer ${token}` },
+                body: formData,
+            });
+            if (!response.ok)
+                throw new Error('Failed to upload avatar');
+            const data = await response.json();
+            const avatarUrl = data.avatar_url || null;
+            if (profile && avatarUrl) {
+                const updated = { ...profile, avatarUrl };
+                setProfile(updated);
+                client.setUser(updated);
+            }
+            setError(null);
+            return avatarUrl;
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to upload avatar');
+            setError(error);
+            throw error;
+        }
+        finally {
+            setLoading(false);
+        }
+    }, [client, isAuthenticated, profile]);
+    return { profile, loading, error, updateProfile, uploadAvatar, refresh };
+}

package/dist/hooks/use-reincarnation-pool.d.ts

@@ -0,0 +1,10 @@
+interface PoolData {
+    usdc_balance?: number;
+    usdt_balance?: number;
+    mcc_balance?: number;
+    total_stablecoin?: number;
+}
+export declare function useReincarnationPool(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<PoolData>;
+export {};

package/dist/hooks/use-reincarnation-pool.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useReincarnationPool = useReincarnationPool;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useReincarnationPool(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/reincarnation/pool',
+        refetchInterval: options?.refetchInterval ?? 300000,
+    });
+}

package/dist/hooks/use-tech-tree.d.ts

@@ -0,0 +1,3 @@
+export declare function useTechTree(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-tech-tree.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTechTree = useTechTree;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useTechTree(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/tech-tree/user',
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/hooks/use-territory-nfts.d.ts

@@ -0,0 +1,3 @@
+export declare function useTerritoryNFTs(wallet?: string, options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<any>;

package/dist/hooks/use-territory-nfts.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useTerritoryNFTs = useTerritoryNFTs;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useTerritoryNFTs(wallet, options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: `/territory/nfts/${wallet}`,
+        skip: !wallet,
+        refetchInterval: options?.refetchInterval ?? 0,
+    });
+}

package/dist/hooks/use-user-level.d.ts

@@ -0,0 +1,10 @@
+interface UserLevelData {
+    level: string;
+    title?: string | null;
+    upgrade_progress?: Record<string, any>;
+    mining_weight?: Record<string, number>;
+}
+export declare function useUserLevel(options?: {
+    refetchInterval?: number;
+}): import("./use-api-query").UseApiQueryResult<UserLevelData>;
+export {};

package/dist/hooks/use-user-level.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useUserLevel = useUserLevel;
+// AI-generated · AI-managed · AI-maintained
+const use_api_query_1 = require("./use-api-query");
+function useUserLevel(options) {
+    return (0, use_api_query_1.useApiQuery)({
+        path: '/users/me/level',
+        requireAuth: true,
+        refetchInterval: options?.refetchInterval ?? 120000,
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,22 @@
+export { MicrocosmAuthProvider, useAuth } from './provider';
+export { AuthCallback } from './callback';
+export { withAuth } from './with-auth';
+export { RequireRole } from './require-role';
+export { useMCD } from './hooks/use-mcd';
+export { useMCC } from './hooks/use-mcc';
+export { useProfile } from './hooks/use-profile';
+export { useApiQuery } from './hooks/use-api-query';
+export { useMCCPrice } from './hooks/use-mcc-price';
+export { useMCCStats } from './hooks/use-mcc-stats';
+export { useMCDStats } from './hooks/use-mcd-stats';
+export { useMiningStats } from './hooks/use-mining-stats';
+export { useMiningRecords } from './hooks/use-mining-records';
+export { useUserLevel } from './hooks/use-user-level';
+export { useReincarnationPool } from './hooks/use-reincarnation-pool';
+export { useTerritoryNFTs } from './hooks/use-territory-nfts';
+export { useAuctions } from './hooks/use-auctions';
+export { useOrganizations } from './hooks/use-organizations';
+export { useTechTree } from './hooks/use-tech-tree';
+export { usePriceHistory } from './hooks/use-price-history';
+export { useDashboardSummary } from './hooks/use-dashboard-summary';
+export type { MicrocosmAuthConfig, MicrocosmAPIConfig, User, AuthState, LoginOptions, MCDBalance, MCCBalance, MCCPrice, } from '@microcosmmoney/auth-core';

package/dist/index.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDashboardSummary = exports.usePriceHistory = exports.useTechTree = exports.useOrganizations = exports.useAuctions = exports.useTerritoryNFTs = exports.useReincarnationPool = exports.useUserLevel = exports.useMiningRecords = exports.useMiningStats = exports.useMCDStats = exports.useMCCStats = exports.useMCCPrice = exports.useApiQuery = exports.useProfile = exports.useMCC = exports.useMCD = exports.RequireRole = exports.withAuth = exports.AuthCallback = exports.useAuth = exports.MicrocosmAuthProvider = void 0;
+// AI-generated · AI-managed · AI-maintained
+var provider_1 = require("./provider");
+Object.defineProperty(exports, "MicrocosmAuthProvider", { enumerable: true, get: function () { return provider_1.MicrocosmAuthProvider; } });
+Object.defineProperty(exports, "useAuth", { enumerable: true, get: function () { return provider_1.useAuth; } });
+var callback_1 = require("./callback");
+Object.defineProperty(exports, "AuthCallback", { enumerable: true, get: function () { return callback_1.AuthCallback; } });
+var with_auth_1 = require("./with-auth");
+Object.defineProperty(exports, "withAuth", { enumerable: true, get: function () { return with_auth_1.withAuth; } });
+var require_role_1 = require("./require-role");
+Object.defineProperty(exports, "RequireRole", { enumerable: true, get: function () { return require_role_1.RequireRole; } });
+var use_mcd_1 = require("./hooks/use-mcd");
+Object.defineProperty(exports, "useMCD", { enumerable: true, get: function () { return use_mcd_1.useMCD; } });
+var use_mcc_1 = require("./hooks/use-mcc");
+Object.defineProperty(exports, "useMCC", { enumerable: true, get: function () { return use_mcc_1.useMCC; } });
+var use_profile_1 = require("./hooks/use-profile");
+Object.defineProperty(exports, "useProfile", { enumerable: true, get: function () { return use_profile_1.useProfile; } });
+var use_api_query_1 = require("./hooks/use-api-query");
+Object.defineProperty(exports, "useApiQuery", { enumerable: true, get: function () { return use_api_query_1.useApiQuery; } });
+var use_mcc_price_1 = require("./hooks/use-mcc-price");
+Object.defineProperty(exports, "useMCCPrice", { enumerable: true, get: function () { return use_mcc_price_1.useMCCPrice; } });
+var use_mcc_stats_1 = require("./hooks/use-mcc-stats");
+Object.defineProperty(exports, "useMCCStats", { enumerable: true, get: function () { return use_mcc_stats_1.useMCCStats; } });
+var use_mcd_stats_1 = require("./hooks/use-mcd-stats");
+Object.defineProperty(exports, "useMCDStats", { enumerable: true, get: function () { return use_mcd_stats_1.useMCDStats; } });
+var use_mining_stats_1 = require("./hooks/use-mining-stats");
+Object.defineProperty(exports, "useMiningStats", { enumerable: true, get: function () { return use_mining_stats_1.useMiningStats; } });
+var use_mining_records_1 = require("./hooks/use-mining-records");
+Object.defineProperty(exports, "useMiningRecords", { enumerable: true, get: function () { return use_mining_records_1.useMiningRecords; } });
+var use_user_level_1 = require("./hooks/use-user-level");
+Object.defineProperty(exports, "useUserLevel", { enumerable: true, get: function () { return use_user_level_1.useUserLevel; } });
+var use_reincarnation_pool_1 = require("./hooks/use-reincarnation-pool");
+Object.defineProperty(exports, "useReincarnationPool", { enumerable: true, get: function () { return use_reincarnation_pool_1.useReincarnationPool; } });
+var use_territory_nfts_1 = require("./hooks/use-territory-nfts");
+Object.defineProperty(exports, "useTerritoryNFTs", { enumerable: true, get: function () { return use_territory_nfts_1.useTerritoryNFTs; } });
+var use_auctions_1 = require("./hooks/use-auctions");
+Object.defineProperty(exports, "useAuctions", { enumerable: true, get: function () { return use_auctions_1.useAuctions; } });
+var use_organizations_1 = require("./hooks/use-organizations");
+Object.defineProperty(exports, "useOrganizations", { enumerable: true, get: function () { return use_organizations_1.useOrganizations; } });
+var use_tech_tree_1 = require("./hooks/use-tech-tree");
+Object.defineProperty(exports, "useTechTree", { enumerable: true, get: function () { return use_tech_tree_1.useTechTree; } });
+var use_price_history_1 = require("./hooks/use-price-history");
+Object.defineProperty(exports, "usePriceHistory", { enumerable: true, get: function () { return use_price_history_1.usePriceHistory; } });
+var use_dashboard_summary_1 = require("./hooks/use-dashboard-summary");
+Object.defineProperty(exports, "useDashboardSummary", { enumerable: true, get: function () { return use_dashboard_summary_1.useDashboardSummary; } });

package/dist/provider.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { MicrocosmAuthClient, MicrocosmAuthConfig, AuthState, LoginOptions } from '@microcosmmoney/auth-core';
+interface AuthContextType extends AuthState {
+    login: (options?: LoginOptions) => void;
+    logout: () => Promise<void>;
+    getAccessToken: () => Promise<string | null>;
+    client: MicrocosmAuthClient;
+}
+export declare function MicrocosmAuthProvider({ children, ...config }: MicrocosmAuthConfig & {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useAuth(): AuthContextType;
+export {};

package/dist/provider.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MicrocosmAuthProvider = MicrocosmAuthProvider;
+exports.useAuth = useAuth;
+const jsx_runtime_1 = require("react/jsx-runtime");
+// AI-generated · AI-managed · AI-maintained
+const react_1 = require("react");
+const auth_core_1 = require("@microcosmmoney/auth-core");
+const AuthContext = (0, react_1.createContext)(null);
+function MicrocosmAuthProvider({ children, ...config }) {
+    const [state, setState] = (0, react_1.useState)({
+        user: null,
+        isAuthenticated: false,
+        isLoading: true,
+        error: null,
+    });
+    const client = (0, react_1.useMemo)(() => new auth_core_1.MicrocosmAuthClient(config), [config.clientId]);
+    (0, react_1.useEffect)(() => {
+        const user = client.getUser();
+        setState({
+            user,
+            isAuthenticated: client.isAuthenticated(),
+            isLoading: false,
+            error: null,
+        });
+        const unsubscribe = client.onAuthStateChange((updatedUser) => {
+            setState(prev => ({
+                ...prev,
+                user: updatedUser,
+                isAuthenticated: !!updatedUser,
+            }));
+        });
+        return unsubscribe;
+    }, [client]);
+    const login = (0, react_1.useCallback)((options) => client.login(options), [client]);
+    const logout = (0, react_1.useCallback)(() => client.logout(), [client]);
+    const getAccessToken = (0, react_1.useCallback)(() => client.getAccessToken(), [client]);
+    const value = {
+        ...state,
+        login,
+        logout,
+        getAccessToken,
+        client,
+    };
+    return (0, jsx_runtime_1.jsx)(AuthContext.Provider, { value: value, children: children });
+}
+function useAuth() {
+    const context = (0, react_1.useContext)(AuthContext);
+    if (!context) {
+        throw new Error('useAuth must be used within <MicrocosmAuthProvider>. ' +
+            'Wrap your app with <MicrocosmAuthProvider clientId="..." redirectUri="/auth/callback">');
+    }
+    return context;
+}

package/dist/require-role.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+interface RequireRoleProps {
+    roles: string[];
+    children: React.ReactNode;
+    fallback?: React.ReactNode;
+}
+export declare function RequireRole({ roles, children, fallback }: RequireRoleProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/require-role.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequireRole = RequireRole;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const provider_1 = require("./provider");
+function RequireRole({ roles, children, fallback }) {
+    const { user } = (0, provider_1.useAuth)();
+    if (!user || !roles.includes(user.role)) {
+        return fallback ? (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: fallback }) : null;
+    }
+    return (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: children });
+}

package/dist/server/index.d.ts

@@ -0,0 +1 @@
+export { createTokenExchangeHandler, createProfileHandler } from './token-exchange';

package/dist/server/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProfileHandler = exports.createTokenExchangeHandler = void 0;
+// AI-generated · AI-managed · AI-maintained
+var token_exchange_1 = require("./token-exchange");
+Object.defineProperty(exports, "createTokenExchangeHandler", { enumerable: true, get: function () { return token_exchange_1.createTokenExchangeHandler; } });
+Object.defineProperty(exports, "createProfileHandler", { enumerable: true, get: function () { return token_exchange_1.createProfileHandler; } });

package/dist/server/token-exchange.d.ts

@@ -0,0 +1,12 @@
+interface TokenExchangeConfig {
+    clientId: string;
+    clientSecret: string;
+    tokenEndpoint?: string;
+    redirectUri?: string;
+}
+export declare function createTokenExchangeHandler(config: TokenExchangeConfig): (request: Request) => Promise<Response>;
+export declare function createProfileHandler(config?: {
+    openApiBase?: string;
+    enrich?: (profile: Record<string, unknown>, token: string) => Promise<Record<string, unknown>>;
+}): (request: Request) => Promise<Response>;
+export {};

package/dist/server/token-exchange.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTokenExchangeHandler = createTokenExchangeHandler;
+exports.createProfileHandler = createProfileHandler;
+function createTokenExchangeHandler(config) {
+    const tokenEndpoint = config.tokenEndpoint || 'https://microcosm.money/api/oauth/token';
+    return async function POST(request) {
+        try {
+            const body = await request.json();
+            if (!config.clientSecret) {
+                return jsonResponse({ error: 'server_error', error_description: 'OAuth not configured' }, 500);
+            }
+            const grantType = body.grant_type || 'authorization_code';
+            const tokenBody = {
+                grant_type: grantType,
+                client_id: config.clientId,
+                client_secret: config.clientSecret,
+            };
+            if (grantType === 'authorization_code') {
+                if (!body.code) {
+                    return jsonResponse({ error: 'invalid_request', error_description: 'Missing authorization code' }, 400);
+                }
+                tokenBody.code = body.code;
+                const origin = request.headers.get('origin') || '';
+                tokenBody.redirect_uri = origin
+                    ? `${origin}/auth/callback`
+                    : config.redirectUri || '';
+            }
+            else if (grantType === 'refresh_token') {
+                if (!body.refresh_token) {
+                    return jsonResponse({ error: 'invalid_request', error_description: 'Missing refresh token' }, 400);
+                }
+                tokenBody.refresh_token = body.refresh_token;
+            }
+            else {
+                return jsonResponse({ error: 'unsupported_grant_type', error_description: `Unsupported: ${grantType}` }, 400);
+            }
+            const tokenResponse = await fetch(tokenEndpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(tokenBody),
+            });
+            if (!tokenResponse.ok) {
+                const errorData = await safeJson(tokenResponse);
+                console.error('[MicrocosmAuth] Token exchange failed:', errorData);
+                return jsonResponse({
+                    error: errorData.error || 'token_error',
+                    error_description: errorData.error_description || 'Token exchange failed',
+                }, tokenResponse.status);
+            }
+            const tokenData = await tokenResponse.json();
+            return jsonResponse({
+                access_token: tokenData.access_token,
+                refresh_token: tokenData.refresh_token,
+                expires_in: tokenData.expires_in,
+                user_id: tokenData.user_id,
+            });
+        }
+        catch (error) {
+            console.error('[MicrocosmAuth] Exchange error:', error);
+            return jsonResponse({
+                error: 'server_error',
+                error_description: error instanceof Error ? error.message : 'Internal server error',
+            }, 500);
+        }
+    };
+}
+function createProfileHandler(config) {
+    const openApiBase = config?.openApiBase || 'https://api.microcosm.money';
+    return async function GET(request) {
+        try {
+            const authHeader = request.headers.get('authorization');
+            if (!authHeader) {
+                return jsonResponse({ error: 'unauthorized', message: 'Missing authorization header' }, 401);
+            }
+            const token = authHeader.replace('Bearer ', '');
+            const profileRes = await fetch(`${openApiBase}/v1/users/me/profile`, {
+                headers: { Authorization: `Bearer ${token}` },
+            });
+            if (!profileRes.ok) {
+                return jsonResponse({ error: 'profile_error', message: 'Failed to fetch profile' }, profileRes.status);
+            }
+            let profile = await profileRes.json();
+            if (profile.data)
+                profile = profile.data;
+            if (profile.user)
+                profile = profile.user;
+            if (config?.enrich) {
+                profile = await config.enrich(profile, token);
+            }
+            return jsonResponse(profile);
+        }
+        catch (error) {
+            console.error('[MicrocosmAuth] Profile error:', error);
+            return jsonResponse({ error: 'server_error', message: error instanceof Error ? error.message : 'Internal error' }, 500);
+        }
+    };
+}
+function jsonResponse(data, status = 200) {
+    return new Response(JSON.stringify(data), {
+        status,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+async function safeJson(response) {
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+        return response.json();
+    }
+    const text = await response.text();
+    return { error: 'Non-JSON Response', error_description: text.substring(0, 200) };
+}

package/dist/with-auth.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface WithAuthOptions {
+    redirectTo?: string;
+    loadingComponent?: React.ReactNode;
+}
+export declare function withAuth<P extends object>(Component: React.ComponentType<P>, options?: WithAuthOptions): {
+    (props: P): import("react/jsx-runtime").JSX.Element | null;
+    displayName: string;
+};
+export {};

package/dist/with-auth.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withAuth = withAuth;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const provider_1 = require("./provider");
+function withAuth(Component, options = {}) {
+    const { redirectTo = '/login', loadingComponent } = options;
+    function WithAuthComponent(props) {
+        const { user, isLoading } = (0, provider_1.useAuth)();
+        if (isLoading) {
+            return loadingComponent ? (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: loadingComponent }) : null;
+        }
+        if (!user) {
+            if (typeof window !== 'undefined') {
+                window.location.href = redirectTo;
+            }
+            return null;
+        }
+        return (0, jsx_runtime_1.jsx)(Component, { ...props });
+    }
+    WithAuthComponent.displayName = `withAuth(${Component.displayName || Component.name || 'Component'})`;
+    return WithAuthComponent;
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@microcosmmoney/auth-react",
+  "version": "1.0.0",
+  "description": "Microcosm OAuth 2.0 React/Next.js adapter",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "default": "./dist/server/index.js"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "dependencies": {
+    "@microcosmmoney/auth-core": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "react": "^18.0.0",
+    "typescript": "^5.3.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MicrocosmMoney/Microcosm"
+  }
+}