@cranberry-money/shared-services 1.12.1 → 3.0.0

package/dist/query/QueryClient.js

@@ -1,136 +0,0 @@
-/**
- * Shared React Query client configuration
- *
- * Provides platform-optimized React Query configurations for web and mobile
- * with appropriate caching, retry, and offline behavior settings.
- */
-import { QueryClient } from '@tanstack/react-query';
-/**
- * Create a QueryClient with platform-optimized defaults
- */
-export const createQueryClient = (options) => {
-    const { platform, defaultStaleTime, defaultRetryCount, enableOfflineSupport = platform === 'mobile', } = options;
-    // Platform-specific defaults
-    const platformDefaults = getPlatformDefaults(platform);
-    const config = {
-        defaultOptions: {
-            queries: {
-                // Stale time - how long data stays fresh
-                staleTime: defaultStaleTime ?? platformDefaults.staleTime,
-                // Cache time - how long data stays in cache after becoming stale
-                gcTime: platformDefaults.gcTime,
-                // Retry configuration
-                retry: defaultRetryCount ?? platformDefaults.retry,
-                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 30000),
-                // Refetch behavior
-                refetchOnWindowFocus: platformDefaults.refetchOnWindowFocus,
-                refetchOnReconnect: platformDefaults.refetchOnReconnect,
-                refetchOnMount: true,
-                // Network mode for offline support
-                networkMode: enableOfflineSupport ? 'offlineFirst' : 'online',
-            },
-            mutations: {
-                // Retry mutations on network errors
-                retry: platform === 'mobile' ? 2 : 1,
-                retryDelay: (attemptIndex) => Math.min(1000 * 2 ** attemptIndex, 10000),
-                // Network mode for offline support
-                networkMode: enableOfflineSupport ? 'offlineFirst' : 'online',
-            },
-        },
-    };
-    return new QueryClient(config);
-};
-/**
- * Get platform-specific default configurations
- */
-function getPlatformDefaults(platform) {
-    if (platform === 'mobile') {
-        return {
-            // Mobile: Longer stale times for better offline experience
-            staleTime: 5 * 60 * 1000, // 5 minutes
-            gcTime: 10 * 60 * 1000, // 10 minutes
-            retry: 3, // More retries for unstable connections
-            refetchOnWindowFocus: false, // No window focus on mobile
-            refetchOnReconnect: true, // Refetch when network reconnects
-        };
-    }
-    else {
-        return {
-            // Web: Shorter stale times for more responsive experience
-            staleTime: 30 * 1000, // 30 seconds
-            gcTime: 5 * 60 * 1000, // 5 minutes
-            retry: 1, // Single retry for stable connections
-            refetchOnWindowFocus: true, // Refetch when user returns to tab
-            refetchOnReconnect: true, // Refetch when network reconnects
-        };
-    }
-}
-/**
- * Default query keys factory
- * Provides consistent query key structure across the application
- */
-export const queryKeys = {
-    // Authentication
-    auth: {
-        profile: () => ['auth', 'profile'],
-        status: () => ['auth', 'status'],
-    },
-    // Portfolios
-    portfolios: {
-        all: () => ['portfolios'],
-        detail: (id) => ['portfolios', id],
-        holdings: (id) => ['portfolios', id, 'holdings'],
-        allocations: (id) => ['portfolios', id, 'allocations'],
-    },
-    // Instruments
-    instruments: {
-        all: (filters) => ['instruments', filters],
-        detail: (id) => ['instruments', id],
-        search: (query) => ['instruments', 'search', query],
-    },
-    // Trades
-    trades: {
-        all: (filters) => ['trades', filters],
-        target: (filters) => ['trades', 'target', filters],
-        detail: (id) => ['trades', id],
-    },
-    // Reference data
-    reference: {
-        countries: () => ['reference', 'countries'],
-        sectors: () => ['reference', 'sectors'],
-        industries: () => ['reference', 'industries'],
-        exchanges: () => ['reference', 'exchanges'],
-    },
-    // Users
-    users: {
-        profile: () => ['users', 'profile'],
-        preferences: () => ['users', 'preferences'],
-    },
-};
-/**
- * Common query options factory
- */
-export const createQueryOptions = {
-    /**
-     * Create options for frequently updated data
-     */
-    realtime: (platform) => ({
-        staleTime: platform === 'mobile' ? 1 * 60 * 1000 : 10 * 1000, // 1min mobile, 10s web
-        refetchInterval: platform === 'mobile' ? 2 * 60 * 1000 : 30 * 1000, // 2min mobile, 30s web
-    }),
-    /**
-     * Create options for static reference data
-     */
-    reference: () => ({
-        staleTime: 24 * 60 * 60 * 1000, // 24 hours
-        gcTime: 48 * 60 * 60 * 1000, // 48 hours
-        refetchOnWindowFocus: false,
-        refetchOnReconnect: false,
-    }),
-    /**
-     * Create options for user-specific data
-     */
-    user: (platform) => ({
-        staleTime: platform === 'mobile' ? 10 * 60 * 1000 : 2 * 60 * 1000, // 10min mobile, 2min web
-    }),
-};

package/dist/query/useAuth.d.ts

@@ -1,64 +0,0 @@
-/**
- * Shared authentication React Query hooks
- *
- * Provides consistent authentication state management and operations
- * across web and mobile platforms with proper query invalidation.
- */
-import { type UseMutationOptions } from '@tanstack/react-query';
-import type { AuthService, SigninPayload, SignupPayload, EmailVerificationPayload } from '../services/AuthService';
-export interface UseAuthOptions {
-    authService: AuthService;
-    enabled?: boolean;
-}
-export interface AuthMutationOptions<TData, TVariables> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationFn'> {
-    authService: AuthService;
-}
-/**
- * Get current user profile with authentication status
- */
-export declare function useProfile({ authService, enabled }: UseAuthOptions): import("@tanstack/react-query").UseQueryResult<import("..").UserProfile, Error>;
-/**
- * Check authentication status
- */
-export declare function useAuthStatus({ authService, enabled }: UseAuthOptions): import("@tanstack/react-query").UseQueryResult<{
-    authenticated: boolean;
-}, Error>;
-/**
- * Sign in mutation
- */
-export declare function useSignin(options: AuthMutationOptions<unknown, SigninPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, SigninPayload, unknown>;
-/**
- * Sign out mutation
- */
-export declare function useSignout(options: AuthMutationOptions<unknown, void>): import("@tanstack/react-query").UseMutationResult<unknown, Error, void, unknown>;
-/**
- * Sign up mutation
- */
-export declare function useSignup(options: AuthMutationOptions<unknown, SignupPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, SignupPayload, unknown>;
-/**
- * Email verification mutation
- */
-export declare function useVerifyEmail(options: AuthMutationOptions<unknown, EmailVerificationPayload>): import("@tanstack/react-query").UseMutationResult<unknown, Error, EmailVerificationPayload, unknown>;
-/**
- * Resend verification code mutation
- */
-export declare function useResendVerification(options: AuthMutationOptions<unknown, void>): import("@tanstack/react-query").UseMutationResult<unknown, Error, void, unknown>;
-/**
- * Composite auth hook that provides complete authentication state
- */
-export declare function useAuth(options: UseAuthOptions): {
-    user: import("..").UserProfile | undefined;
-    isAuthenticated: boolean;
-    isLoading: boolean;
-    isLoadingProfile: boolean;
-    isLoadingStatus: boolean;
-    error: Error | null;
-    profileError: Error | null;
-    statusError: Error | null;
-    refetchProfile: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").UserProfile, Error>>;
-    refetchStatus: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
-        authenticated: boolean;
-    }, Error>>;
-    refetch: () => void;
-};
-//# sourceMappingURL=useAuth.d.ts.map

package/dist/query/useAuth.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/query/useAuth.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAyC,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACvG,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,aAAa,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAC;AAGnH,MAAM,WAAW,cAAc;IAC7B,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,mBAAmB,CAAC,KAAK,EAAE,UAAU,CAAE,SACtD,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC;IAChE,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,WAAW,EAAE,OAAc,EAAE,EAAE,cAAc,mFAczE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,EAAE,WAAW,EAAE,OAAc,EAAE,EAAE,cAAc;;UAQ5E;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,6FAgB7E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,oFAerE;AAED;;GAEG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,aAAa,CAAC,6FAe7E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,wBAAwB,CAAC,wGAe7F;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,oFAOhF;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,cAAc;;;;;;;;;;;;;;EA2B9C"}

package/dist/query/useAuth.js

@@ -1,144 +0,0 @@
-/**
- * Shared authentication React Query hooks
- *
- * Provides consistent authentication state management and operations
- * across web and mobile platforms with proper query invalidation.
- */
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
-import { queryKeys } from './QueryClient';
-/**
- * Get current user profile with authentication status
- */
-export function useProfile({ authService, enabled = true }) {
-    return useQuery({
-        queryKey: queryKeys.auth.profile(),
-        queryFn: () => authService.getProfile(),
-        enabled,
-        retry: (failureCount, error) => {
-            // Don't retry on authentication errors
-            if (error && 'status' in error && error.status === 401) {
-                return false;
-            }
-            return failureCount < 3;
-        },
-        staleTime: 2 * 60 * 1000, // 2 minutes
-    });
-}
-/**
- * Check authentication status
- */
-export function useAuthStatus({ authService, enabled = true }) {
-    return useQuery({
-        queryKey: queryKeys.auth.status(),
-        queryFn: () => authService.checkStatus(),
-        enabled,
-        retry: false, // Don't retry auth status checks
-        staleTime: 1 * 60 * 1000, // 1 minute
-    });
-}
-/**
- * Sign in mutation
- */
-export function useSignin(options) {
-    const queryClient = useQueryClient();
-    const { authService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: (data) => authService.signin(data),
-        onSuccess: (...args) => {
-            // Invalidate auth-related queries
-            queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
-            queryClient.invalidateQueries({ queryKey: queryKeys.auth.status() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Sign out mutation
- */
-export function useSignout(options) {
-    const queryClient = useQueryClient();
-    const { authService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: () => authService.signout(),
-        onSuccess: (...args) => {
-            // Clear all cached data on signout
-            queryClient.clear();
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Sign up mutation
- */
-export function useSignup(options) {
-    const { authService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: (data) => authService.signup(data),
-        onSuccess: (...args) => {
-            // Optionally invalidate auth queries if signup auto-signs in
-            // const queryClient = useQueryClient();
-            // queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Email verification mutation
- */
-export function useVerifyEmail(options) {
-    const queryClient = useQueryClient();
-    const { authService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: (data) => authService.verifyEmail(data),
-        onSuccess: (...args) => {
-            // Invalidate profile to get updated verification status
-            queryClient.invalidateQueries({ queryKey: queryKeys.auth.profile() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Resend verification code mutation
- */
-export function useResendVerification(options) {
-    const { authService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: () => authService.resendVerificationCode(),
-        ...mutationOptions,
-    });
-}
-/**
- * Composite auth hook that provides complete authentication state
- */
-export function useAuth(options) {
-    const profileQuery = useProfile(options);
-    const statusQuery = useAuthStatus(options);
-    return {
-        // Data
-        user: profileQuery.data,
-        isAuthenticated: !!(statusQuery.data && profileQuery.data),
-        // Loading states
-        isLoading: profileQuery.isLoading || statusQuery.isLoading,
-        isLoadingProfile: profileQuery.isLoading,
-        isLoadingStatus: statusQuery.isLoading,
-        // Error states
-        error: profileQuery.error || statusQuery.error,
-        profileError: profileQuery.error,
-        statusError: statusQuery.error,
-        // Refetch functions
-        refetchProfile: profileQuery.refetch,
-        refetchStatus: statusQuery.refetch,
-        refetch: () => {
-            profileQuery.refetch();
-            statusQuery.refetch();
-        },
-    };
-}

package/dist/query/usePortfolios.d.ts

@@ -1,79 +0,0 @@
-/**
- * Shared portfolio React Query hooks
- *
- * Provides consistent portfolio data management and operations
- * with optimized caching and invalidation patterns.
- */
-import { type UseMutationOptions } from '@tanstack/react-query';
-import type { PortfolioService, Portfolio, CreatePortfolioPayload, UpdatePortfolioPayload, PortfolioListFilters } from '../services/PortfolioService';
-export interface UsePortfolioServiceOptions {
-    portfolioService: PortfolioService;
-}
-export interface PortfolioMutationOptions<TData, TVariables> extends Omit<UseMutationOptions<TData, Error, TVariables>, 'mutationFn'> {
-    portfolioService: PortfolioService;
-}
-/**
- * Get all portfolios with filtering
- */
-export declare function usePortfolios({ portfolioService }: UsePortfolioServiceOptions, filters?: PortfolioListFilters, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("..").PaginatedResponse<Portfolio>, Error>;
-/**
- * Get specific portfolio by ID
- */
-export declare function usePortfolio({ portfolioService }: UsePortfolioServiceOptions, portfolioId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<Portfolio, Error>;
-/**
- * Get portfolio holdings
- */
-export declare function usePortfolioHoldings({ portfolioService }: UsePortfolioServiceOptions, portfolioId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("..").AssetHolding[], Error>;
-/**
- * Get portfolio allocations
- */
-export declare function usePortfolioAllocations({ portfolioService }: UsePortfolioServiceOptions, portfolioId: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("..").AssetAllocation[], Error>;
-/**
- * Get portfolio performance data
- */
-export declare function usePortfolioPerformance({ portfolioService }: UsePortfolioServiceOptions, portfolioId: string, timeRange?: string, enabled?: boolean): import("@tanstack/react-query").UseQueryResult<import("..").PerformanceData, Error>;
-/**
- * Create portfolio mutation
- */
-export declare function useCreatePortfolio(options: PortfolioMutationOptions<Portfolio, CreatePortfolioPayload>): import("@tanstack/react-query").UseMutationResult<Portfolio, Error, CreatePortfolioPayload, unknown>;
-/**
- * Update portfolio mutation
- */
-export declare function useUpdatePortfolio(options: PortfolioMutationOptions<Portfolio, {
-    id: string;
-    data: UpdatePortfolioPayload;
-}>): import("@tanstack/react-query").UseMutationResult<Portfolio, Error, {
-    id: string;
-    data: UpdatePortfolioPayload;
-}, unknown>;
-/**
- * Delete portfolio mutation
- */
-export declare function useDeletePortfolio(options: PortfolioMutationOptions<void, string>): import("@tanstack/react-query").UseMutationResult<void, Error, string, unknown>;
-/**
- * Infinite query for portfolios (useful for large lists)
- */
-export declare function useInfinitePortfolios({ portfolioService }: UsePortfolioServiceOptions, filters?: PortfolioListFilters): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/query-core").InfiniteData<import("..").PaginatedResponse<Portfolio>, unknown>, Error>;
-/**
- * Composite hook for complete portfolio management
- */
-export declare function usePortfolioManagement(serviceOptions: UsePortfolioServiceOptions, portfolioId?: string): {
-    portfolios: Portfolio[];
-    portfolio: Portfolio | undefined;
-    holdings: import("..").AssetHolding[];
-    allocations: import("..").AssetAllocation[];
-    isLoadingPortfolios: boolean;
-    isLoadingPortfolio: boolean;
-    isLoadingHoldings: boolean;
-    isLoadingAllocations: boolean;
-    isLoading: boolean;
-    portfoliosError: Error | null;
-    portfolioError: Error | null;
-    holdingsError: Error | null;
-    allocationsError: Error | null;
-    refetchPortfolios: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").PaginatedResponse<Portfolio>, Error>>;
-    refetchPortfolio: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<Portfolio, Error>>;
-    refetchHoldings: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").AssetHolding[], Error>>;
-    refetchAllocations: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<import("..").AssetAllocation[], Error>>;
-};
-//# sourceMappingURL=usePortfolios.d.ts.map

package/dist/query/usePortfolios.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"usePortfolios.d.ts","sourceRoot":"","sources":["../../src/query/usePortfolios.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAA2D,KAAK,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AACzH,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EACT,sBAAsB,EACtB,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,8BAA8B,CAAC;AAGtC,MAAM,WAAW,0BAA0B;IACzC,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED,MAAM,WAAW,wBAAwB,CAAC,KAAK,EAAE,UAAU,CAAE,SAC3D,IAAI,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,UAAU,CAAC,EAAE,YAAY,CAAC;IAChE,gBAAgB,EAAE,gBAAgB,CAAC;CACpC;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,OAAO,GAAE,oBAAyB,EAClC,OAAO,GAAE,OAAc,oGAQxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,OAAc,oEAQxB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,OAAc,sFAQxB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,OAAc,yFAQxB;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,WAAW,EAAE,MAAM,EACnB,SAAS,GAAE,MAAa,EACxB,OAAO,GAAE,OAAc,uFAQxB;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,wBAAwB,CAAC,SAAS,EAAE,sBAAsB,CAAC,wGAqBtG;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,wBAAwB,CAAC,SAAS,EAAE;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,sBAAsB,CAAA;CAAE,CAAC;QAAvC,MAAM;UAAQ,sBAAsB;YAsBzH;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,wBAAwB,CAAC,IAAI,EAAE,MAAM,CAAC,mFAoBjF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,EAAE,gBAAgB,EAAE,EAAE,0BAA0B,EAChD,OAAO,GAAE,oBAAyB,kKAgBnC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,0BAA0B,EAC1C,WAAW,CAAC,EAAE,MAAM;;;;;;;;;;;;;;;;;;EAiCrB"}

package/dist/query/usePortfolios.js

@@ -1,172 +0,0 @@
-/**
- * Shared portfolio React Query hooks
- *
- * Provides consistent portfolio data management and operations
- * with optimized caching and invalidation patterns.
- */
-import { useQuery, useMutation, useQueryClient, useInfiniteQuery } from '@tanstack/react-query';
-import { queryKeys, createQueryOptions } from './QueryClient';
-/**
- * Get all portfolios with filtering
- */
-export function usePortfolios({ portfolioService }, filters = {}, enabled = true) {
-    return useQuery({
-        queryKey: queryKeys.portfolios.all(),
-        queryFn: () => portfolioService.getPortfolios(filters),
-        enabled,
-        ...createQueryOptions.user('web'), // Adjust based on platform
-    });
-}
-/**
- * Get specific portfolio by ID
- */
-export function usePortfolio({ portfolioService }, portfolioId, enabled = true) {
-    return useQuery({
-        queryKey: queryKeys.portfolios.detail(portfolioId),
-        queryFn: () => portfolioService.getPortfolio(portfolioId),
-        enabled: enabled && !!portfolioId,
-        ...createQueryOptions.user('web'),
-    });
-}
-/**
- * Get portfolio holdings
- */
-export function usePortfolioHoldings({ portfolioService }, portfolioId, enabled = true) {
-    return useQuery({
-        queryKey: queryKeys.portfolios.holdings(portfolioId),
-        queryFn: () => portfolioService.getHoldings(portfolioId),
-        enabled: enabled && !!portfolioId,
-        ...createQueryOptions.realtime('web'), // Holdings update frequently
-    });
-}
-/**
- * Get portfolio allocations
- */
-export function usePortfolioAllocations({ portfolioService }, portfolioId, enabled = true) {
-    return useQuery({
-        queryKey: queryKeys.portfolios.allocations(portfolioId),
-        queryFn: () => portfolioService.getAllocations(portfolioId),
-        enabled: enabled && !!portfolioId,
-        ...createQueryOptions.user('web'),
-    });
-}
-/**
- * Get portfolio performance data
- */
-export function usePortfolioPerformance({ portfolioService }, portfolioId, timeRange = '1Y', enabled = true) {
-    return useQuery({
-        queryKey: ['portfolios', portfolioId, 'performance', timeRange],
-        queryFn: () => portfolioService.getPerformance(portfolioId, timeRange),
-        enabled: enabled && !!portfolioId,
-        staleTime: 5 * 60 * 1000, // 5 minutes - performance data doesn't change frequently
-    });
-}
-/**
- * Create portfolio mutation
- */
-export function useCreatePortfolio(options) {
-    const queryClient = useQueryClient();
-    const { portfolioService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: (data) => portfolioService.createPortfolio(data),
-        onSuccess: (newPortfolio, ...args) => {
-            // Add new portfolio to the cache
-            queryClient.setQueryData(queryKeys.portfolios.detail(newPortfolio.id), newPortfolio);
-            // Invalidate portfolios list to include new portfolio
-            queryClient.invalidateQueries({ queryKey: queryKeys.portfolios.all() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(newPortfolio, ...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Update portfolio mutation
- */
-export function useUpdatePortfolio(options) {
-    const queryClient = useQueryClient();
-    const { portfolioService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: ({ id, data }) => portfolioService.updatePortfolio(id, data),
-        onSuccess: (updatedPortfolio, { id }, ...args) => {
-            // Update portfolio in cache
-            queryClient.setQueryData(queryKeys.portfolios.detail(id), updatedPortfolio);
-            // Invalidate portfolios list to reflect changes
-            queryClient.invalidateQueries({ queryKey: queryKeys.portfolios.all() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(updatedPortfolio, { id, data: { name: updatedPortfolio.name } }, ...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Delete portfolio mutation
- */
-export function useDeletePortfolio(options) {
-    const queryClient = useQueryClient();
-    const { portfolioService, ...mutationOptions } = options;
-    return useMutation({
-        mutationFn: (id) => portfolioService.deletePortfolio(id),
-        onSuccess: (_, portfolioId, ...args) => {
-            // Remove portfolio from cache
-            queryClient.removeQueries({ queryKey: queryKeys.portfolios.detail(portfolioId) });
-            queryClient.removeQueries({ queryKey: queryKeys.portfolios.holdings(portfolioId) });
-            queryClient.removeQueries({ queryKey: queryKeys.portfolios.allocations(portfolioId) });
-            // Invalidate portfolios list to reflect deletion
-            queryClient.invalidateQueries({ queryKey: queryKeys.portfolios.all() });
-            // Call user's onSuccess if provided
-            mutationOptions.onSuccess?.(_, portfolioId, ...args);
-        },
-        ...mutationOptions,
-    });
-}
-/**
- * Infinite query for portfolios (useful for large lists)
- */
-export function useInfinitePortfolios({ portfolioService }, filters = {}) {
-    return useInfiniteQuery({
-        queryKey: ['portfolios', 'infinite', filters],
-        queryFn: ({ pageParam = 1 }) => portfolioService.getPortfolios({ ...filters, page: pageParam }),
-        initialPageParam: 1,
-        getNextPageParam: (lastPage) => {
-            if (lastPage.next) {
-                const url = new URL(lastPage.next);
-                return Number(url.searchParams.get('page'));
-            }
-            return undefined;
-        },
-        ...createQueryOptions.user('web'),
-    });
-}
-/**
- * Composite hook for complete portfolio management
- */
-export function usePortfolioManagement(serviceOptions, portfolioId) {
-    const portfoliosQuery = usePortfolios(serviceOptions);
-    const portfolioQuery = usePortfolio(serviceOptions, portfolioId || '', !!portfolioId);
-    const holdingsQuery = usePortfolioHoldings(serviceOptions, portfolioId || '', !!portfolioId);
-    const allocationsQuery = usePortfolioAllocations(serviceOptions, portfolioId || '', !!portfolioId);
-    return {
-        // Data
-        portfolios: portfoliosQuery.data?.results || [],
-        portfolio: portfolioQuery.data,
-        holdings: holdingsQuery.data || [],
-        allocations: allocationsQuery.data || [],
-        // Loading states
-        isLoadingPortfolios: portfoliosQuery.isLoading,
-        isLoadingPortfolio: portfolioQuery.isLoading,
-        isLoadingHoldings: holdingsQuery.isLoading,
-        isLoadingAllocations: allocationsQuery.isLoading,
-        isLoading: portfoliosQuery.isLoading || portfolioQuery.isLoading,
-        // Error states
-        portfoliosError: portfoliosQuery.error,
-        portfolioError: portfolioQuery.error,
-        holdingsError: holdingsQuery.error,
-        allocationsError: allocationsQuery.error,
-        // Refetch functions
-        refetchPortfolios: portfoliosQuery.refetch,
-        refetchPortfolio: portfolioQuery.refetch,
-        refetchHoldings: holdingsQuery.refetch,
-        refetchAllocations: allocationsQuery.refetch,
-    };
-}

package/dist/services/AuthService.d.ts

@@ -1,75 +0,0 @@
-/**
- * Authentication service with React Query integration
- *
- * Provides authentication operations with proper query invalidation
- * and state management across platforms.
- */
-import type { BaseApiClient } from '../core/BaseApiClient';
-import { BaseService } from './BaseService';
-export interface SigninPayload {
-    email: string;
-    password: string;
-}
-export interface SignupPayload {
-    email: string;
-    password: string;
-    first_name: string;
-    last_name: string;
-}
-export interface EmailVerificationPayload {
-    email: string;
-    verification_code: string;
-}
-export interface TokenRefreshPayload {
-    refresh: string;
-}
-export interface TokenRefreshResponse {
-    access: string;
-    refresh: string;
-}
-export interface UserProfile {
-    id: string;
-    email: string;
-    first_name: string;
-    last_name: string;
-    is_verified: boolean;
-    is_signup_completed: boolean;
-}
-export declare class AuthService extends BaseService {
-    constructor(apiClient: BaseApiClient);
-    /**
-     * Sign in user
-     */
-    signin(data: SigninPayload): Promise<unknown>;
-    /**
-     * Sign out user
-     */
-    signout(): Promise<unknown>;
-    /**
-     * Sign up new user
-     */
-    signup(data: SignupPayload): Promise<unknown>;
-    /**
-     * Verify email address
-     */
-    verifyEmail(data: EmailVerificationPayload): Promise<unknown>;
-    /**
-     * Resend verification code
-     */
-    resendVerificationCode(): Promise<unknown>;
-    /**
-     * Refresh authentication tokens
-     */
-    refreshToken(data: TokenRefreshPayload): Promise<TokenRefreshResponse>;
-    /**
-     * Get current user profile
-     */
-    getProfile(): Promise<UserProfile>;
-    /**
-     * Check authentication status
-     */
-    checkStatus(): Promise<{
-        authenticated: boolean;
-    }>;
-}
-//# sourceMappingURL=AuthService.d.ts.map