@umituz/react-native-design-system 4.25.99 → 4.25.101

package/dist/image/presentation/hooks/useImageTransform.d.ts

@@ -0,0 +1,12 @@
+import type { ImageManipulateAction, ImageSaveOptions, ImageCropArea, ImageFlipOptions } from '../../domain/entities/ImageTypes';
+export declare const useImageTransform: () => {
+    resize: (uri: string, width?: number, height?: number, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    crop: (uri: string, cropArea: ImageCropArea, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    rotate: (uri: string, degrees: number, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    flip: (uri: string, flipParams: ImageFlipOptions, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    manipulate: (uri: string, action: ImageManipulateAction, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    resizeToFit: (uri: string, maxWidth: number, maxHeight: number, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    cropToSquare: (uri: string, width: number, height: number, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    isTransforming: boolean;
+    transformError: string | null;
+};

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @umituz/react-native-design-system
+ *
+ * Sub-path imports ONLY. Barrel import is disabled to prevent
+ * bundling unused modules with optional peer dependencies.
+ *
+ * Usage:
+ *   import { DesignSystemProvider, useAppDesignTokens } from "@umituz/react-native-design-system/theme";
+ *   import { AtomicText, AtomicButton } from "@umituz/react-native-design-system/atoms";
+ *   import { FormField } from "@umituz/react-native-design-system/molecules";
+ *   import { generateUUID } from "@umituz/react-native-design-system/uuid";
+ *
+ * Available sub-paths:
+ *   /atoms        - AtomicText, AtomicButton, AtomicIcon, AtomicSpinner, etc.
+ *   /molecules    - FormField, AppNavigation, AlertContainer, BottomSheet, etc.
+ *   /organisms    - Complex screen-level components
+ *   /theme        - DesignSystemProvider, useAppDesignTokens, useTheme
+ *   /typography   - Typography utilities
+ *   /responsive   - useResponsive
+ *   /layouts      - ScreenLayout
+ *   /safe-area    - useSafeAreaInsets
+ *   /exception    - ErrorBoundary, ExceptionErrorState
+ *   /infinite-scroll - useInfiniteScroll, InfiniteScrollList
+ *   /uuid         - generateUUID, isValidUUID
+ *   /timezone     - useTimezone, date utilities
+ *   /offline      - useOffline, OfflineBanner
+ *   /storage      - storageRepository, useStorageState
+ *   /filesystem   - useFilesystem, Directory
+ *   /media        - MediaPickerService
+ *   /image        - AtomicImage, ImageGallery
+ *   /tanstack     - TanstackProvider
+ *   /loading      - LoadingProvider, useGlobalLoading
+ *   /haptics      - HapticService, useHaptics
+ *   /onboarding   - OnboardingScreen
+ *   /gallery      - gallerySaveService
+ *   /carousel     - Carousel components
+ *   /init         - createAppInitializer, createEnvConfig
+ *   /device       - DeviceService, useDeviceInfo
+ */
+export {};

package/dist/infinite-scroll/domain/interfaces/infinite-scroll-list-props.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Infinite Scroll List Props Interface
+ *
+ * Domain interface for component props
+ * Follows SOLID, DRY, KISS principles
+ */
+import type React from "react";
+import type { InfiniteScrollConfig } from "../types/infinite-scroll-config";
+export interface InfiniteScrollListProps<T> {
+    /**
+     * Configuration for infinite scroll
+     */
+    config: InfiniteScrollConfig<T>;
+    /**
+     * Render function for each item
+     */
+    renderItem: (item: T, index: number) => React.ReactElement;
+    /**
+     * Optional: Custom loading component
+     */
+    loadingComponent?: React.ReactElement;
+    /**
+     * Optional: Custom loading more component
+     */
+    loadingMoreComponent?: React.ReactElement;
+    /**
+     * Optional: Custom empty component
+     */
+    emptyComponent?: React.ReactElement;
+    /**
+     * Optional: Custom error component
+     */
+    errorComponent?: (error: string, retry: () => void) => React.ReactElement;
+    /**
+     * Optional: List header component
+     */
+    ListHeaderComponent?: React.ReactElement;
+    /**
+     * Optional: List footer component
+     */
+    ListFooterComponent?: React.ReactElement;
+    /**
+     * Optional: Additional FlatList props
+     */
+    flatListProps?: Omit<React.ComponentProps<typeof import("react-native").FlatList<T>>, "data" | "renderItem" | "keyExtractor" | "onEndReached" | "onEndReachedThreshold" | "onRefresh" | "refreshing" | "ListHeaderComponent" | "ListFooterComponent">;
+}

package/dist/infinite-scroll/domain/types/infinite-scroll-config.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Infinite Scroll Configuration Types
+ *
+ * Domain types for infinite scroll configuration
+ * Follows SOLID, DRY, KISS principles
+ */
+/**
+ * Paginated result for cursor-based pagination
+ */
+export interface PaginatedResult<T> {
+    items: T[];
+    nextCursor: string | null;
+    hasMore: boolean;
+}
+/**
+ * Base configuration shared by all pagination modes
+ */
+interface BaseConfig<T> {
+    /**
+     * Total number of items available (optional, for progress tracking)
+     */
+    totalItems?: number;
+    /**
+     * Number of items to load per page
+     * Default: 20
+     */
+    pageSize?: number;
+    /**
+     * Number of items from the end to trigger loading more
+     * Default: 5 (loads more when 5 items from bottom)
+     */
+    threshold?: number;
+    /**
+     * Enable automatic loading when threshold is reached
+     * Default: true
+     */
+    autoLoad?: boolean;
+    /**
+     * Optional: Function to get unique key for each item
+     * If not provided, uses array index
+     * @param item - Item to get key for
+     * @param index - Item index
+     * @returns Unique key string
+     */
+    getItemKey?: (item: T, index: number) => string;
+}
+/**
+ * Page-based pagination configuration (default)
+ */
+export interface PageBasedConfig<T> extends BaseConfig<T> {
+    /**
+     * Initial page number (0-indexed)
+     * Default: 0
+     */
+    initialPage?: number;
+    /**
+     * Function to fetch data for a specific page
+     * @param page - Page number (0-indexed)
+     * @param pageSize - Number of items per page
+     * @returns Promise resolving to array of items
+     */
+    fetchData: (page: number, pageSize: number) => Promise<T[]>;
+    /**
+     * Optional: Function to check if there are more items
+     * If not provided, checks if last page has fewer items than pageSize
+     * @param lastPage - Last fetched page of items
+     * @param allPages - All fetched pages
+     * @returns true if there are more items to load
+     */
+    hasMore?: (lastPage: T[], allPages: T[][]) => boolean;
+}
+/**
+ * Cursor-based pagination configuration (new, for Firestore)
+ */
+export interface CursorBasedConfig<T> extends BaseConfig<T> {
+    /**
+     * Discriminator for cursor-based mode
+     */
+    paginationMode: "cursor";
+    /**
+     * Function to fetch data using cursor
+     * @param cursor - Cursor for next page (undefined for first page)
+     * @param pageSize - Number of items per page
+     * @returns Promise resolving to paginated result with cursor
+     */
+    fetchCursor: (cursor: string | undefined, pageSize: number) => Promise<PaginatedResult<T>>;
+}
+/**
+ * Infinite scroll configuration (discriminated union)
+ */
+export type InfiniteScrollConfig<T> = PageBasedConfig<T> | CursorBasedConfig<T>;
+export {};

package/dist/infinite-scroll/domain/types/infinite-scroll-return.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Infinite Scroll Return Types
+ *
+ * Domain types for hook return values
+ * Follows SOLID, DRY, KISS principles
+ */
+import type { InfiniteScrollState } from "./infinite-scroll-state";
+export interface UseInfiniteScrollReturn<T> {
+    /**
+     * All loaded items (flattened)
+     */
+    items: T[];
+    /**
+     * Current state
+     */
+    state: InfiniteScrollState<T>;
+    /**
+     * Load next page of items
+     */
+    loadMore: () => Promise<void>;
+    /**
+     * Refresh all data (resets to page 0)
+     */
+    refresh: () => Promise<void>;
+    /**
+     * Reset to initial state
+     */
+    reset: () => void;
+    /**
+     * Check if can load more
+     */
+    canLoadMore: boolean;
+}

package/dist/infinite-scroll/domain/types/infinite-scroll-state.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Infinite Scroll State Types
+ *
+ * Domain types for infinite scroll state management
+ * Follows SOLID, DRY, KISS principles
+ */
+export interface InfiniteScrollState<T> {
+    /**
+     * All loaded items (flattened from pages)
+     */
+    items: T[];
+    /**
+     * All pages of items (used in page-based mode)
+     */
+    pages: T[][];
+    /**
+     * Current page number (0-indexed, page-based mode)
+     */
+    currentPage: number;
+    /**
+     * Current cursor (cursor-based mode)
+     */
+    cursor: string | null;
+    /**
+     * Whether more items are available
+     */
+    hasMore: boolean;
+    /**
+     * Whether currently loading initial data
+     */
+    isLoading: boolean;
+    /**
+     * Whether currently loading more items
+     */
+    isLoadingMore: boolean;
+    /**
+     * Whether currently refreshing
+     */
+    isRefreshing: boolean;
+    /**
+     * Error message if any
+     */
+    error: string | null;
+    /**
+     * Total number of items (if known)
+     */
+    totalItems?: number;
+}

package/dist/infinite-scroll/domain/utils/pagination-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Pagination Utilities
+ *
+ * Pure functions for pagination calculations
+ * Follows SOLID, DRY, KISS principles
+ */
+/**
+ * Calculate onEndReachedThreshold from threshold value
+ * Converts threshold (number of items) to percentage (0-1)
+ *
+ * @param threshold - Number of items from bottom to trigger load
+ * @param defaultThreshold - Default threshold if not provided (default: 0.1 = 10%)
+ * @returns Threshold value between 0.01 and 1.0
+ */
+export declare function calculateEndReachedThreshold(threshold?: number, defaultThreshold?: number): number;
+/**
+ * Calculate pagination slice for client-side pagination
+ *
+ * @param items - All items to paginate
+ * @param page - Page number (0-indexed)
+ * @param pageSize - Number of items per page
+ * @returns Slice of items for the requested page
+ */
+export declare function getPageSlice<T>(items: T[], page: number, pageSize: number): T[];
+/**
+ * Check if there are more items to load
+ *
+ * @param lastPage - Last fetched page
+ * @param allPages - All fetched pages
+ * @param pageSize - Page size
+ * @returns True if there are more items to load
+ */
+export declare function hasMoreItems<T>(lastPage: T[], _allPages: T[][], pageSize: number): boolean;

package/dist/infinite-scroll/domain/utils/type-guards.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Type Guard Utilities
+ *
+ * Runtime type checking for better type safety
+ */
+import type { InfiniteScrollConfig, PageBasedConfig, CursorBasedConfig } from "../types/infinite-scroll-config";
+/**
+ * Check if config is page-based pagination
+ */
+export declare function isPageBasedConfig<T>(config: InfiniteScrollConfig<T>): config is PageBasedConfig<T>;
+/**
+ * Check if config is cursor-based pagination
+ */
+export declare function isCursorBasedConfig<T>(config: InfiniteScrollConfig<T>): config is CursorBasedConfig<T>;
+/**
+ * Check if value is a valid error
+ */
+export declare function isError(value: unknown): value is Error;
+/**
+ * Check if value is a non-null object
+ */
+export declare function isNonNullObject<T>(value: T | null | undefined): value is T;
+/**
+ * Check if array has items
+ */
+export declare function hasItems<T>(items: T[] | null | undefined): items is T[];
+/**
+ * Check if string is not empty
+ */
+export declare function isNonEmptyString(value: string | null | undefined): value is string;

package/dist/infinite-scroll/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * React Native Infinite Scroll
+ *
+ * Modern infinite scroll system for React Native
+ * Follows SOLID, DRY, KISS principles
+ *
+ * Features:
+ * - Page-based and cursor-based pagination
+ * - Automatic retry with exponential backoff
+ * - Request cancellation with AbortController
+ * - Performance monitoring in __DEV__ mode
+ * - Full accessibility support
+ * - Type-safe utilities
+ */
+export type { InfiniteScrollConfig, PaginatedResult, PageBasedConfig, CursorBasedConfig, } from "./domain/types/infinite-scroll-config";
+export type { InfiniteScrollState } from "./domain/types/infinite-scroll-state";
+export type { UseInfiniteScrollReturn } from "./domain/types/infinite-scroll-return";
+export type { InfiniteScrollListProps } from "./domain/interfaces/infinite-scroll-list-props";
+export { calculateEndReachedThreshold, getPageSlice, hasMoreItems, } from "./domain/utils/pagination-utils";
+export { isPageBasedConfig, isCursorBasedConfig, isError, isNonNullObject, hasItems, isNonEmptyString, } from "./domain/utils/type-guards";
+export { useInfiniteScroll } from "./presentation/hooks/useInfiniteScroll";
+export { InfiniteScrollList } from "./presentation/components/infinite-scroll-list";
+export type { EmptyProps, ErrorProps, LoadingProps, LoadingMoreProps, } from "./presentation/components/types";
+export { Loading } from "./presentation/components/loading";
+export { LoadingMore } from "./presentation/components/loading-more";
+export { Empty } from "./presentation/components/empty";
+export { Error } from "./presentation/components/error";

package/dist/infinite-scroll/presentation/components/empty.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Empty Component
+ *
+ * Presentation component for empty state
+ * Fully customizable via props
+ * Accessibility support included
+ */
+import React from "react";
+import type { EmptyProps } from "./types";
+export declare const Empty: React.NamedExoticComponent<EmptyProps>;

package/dist/infinite-scroll/presentation/components/error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Error Component
+ *
+ * Presentation component for error state
+ * Fully customizable via props
+ * Accessibility support included
+ */
+import React from "react";
+import type { ErrorProps } from "./types";
+export declare const Error: React.NamedExoticComponent<ErrorProps>;

package/dist/infinite-scroll/presentation/components/infinite-scroll-list.d.ts

@@ -0,0 +1,9 @@
+/**
+ * InfiniteScrollList Component
+ *
+ * Presentation component for infinite scroll list
+ * Optimized with React.memo for performance
+ */
+import React from "react";
+import type { InfiniteScrollListProps } from "../../domain/interfaces/infinite-scroll-list-props";
+export declare const InfiniteScrollList: <T>(props: InfiniteScrollListProps<T>) => React.ReactElement;

package/dist/infinite-scroll/presentation/components/loading-more.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Loading More Component
+ *
+ * Presentation component for loading more state
+ * Fully customizable via props
+ * Accessibility support included
+ */
+import React from "react";
+import type { LoadingMoreProps } from "./types";
+export declare const LoadingMore: React.NamedExoticComponent<LoadingMoreProps>;

package/dist/infinite-scroll/presentation/components/loading.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Loading Component
+ *
+ * Presentation component for loading state
+ * Fully customizable via props
+ * Accessibility support included
+ */
+import React from "react";
+import type { LoadingProps } from "./types";
+export declare const Loading: React.NamedExoticComponent<LoadingProps>;

package/dist/infinite-scroll/presentation/components/types.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Component Types
+ *
+ * Shared types for presentation components
+ */
+import type { TextStyle, ViewStyle, AccessibilityProps } from "react-native";
+export interface EmptyProps extends AccessibilityProps {
+    /**
+     * Optional text to display
+     * Default: "No items found"
+     */
+    text?: string;
+    /**
+     * Optional accessibility label
+     * Default: "Empty list"
+     */
+    accessibilityLabel?: string;
+    /**
+     * Optional custom style for container
+     */
+    containerStyle?: ViewStyle;
+    /**
+     * Optional custom style for text
+     */
+    textStyle?: TextStyle;
+}
+export interface ErrorProps extends AccessibilityProps {
+    /**
+     * Error message to display
+     */
+    error: string;
+    /**
+     * Retry callback
+     */
+    onRetry: () => void;
+    /**
+     * Optional text for retry button
+     * Default: "Tap to retry"
+     */
+    retryText?: string;
+    /**
+     * Optional accessibility label for error
+     * Default: "Error: {error}"
+     */
+    accessibilityLabel?: string;
+    /**
+     * Optional accessibility hint for retry button
+     * Default: "Double tap to retry"
+     */
+    retryAccessibilityHint?: string;
+    /**
+     * Optional custom style for container
+     */
+    containerStyle?: ViewStyle;
+    /**
+     * Optional custom style for error text
+     */
+    errorTextStyle?: TextStyle;
+    /**
+     * Optional custom style for retry text
+     */
+    retryTextStyle?: TextStyle;
+}
+export interface LoadingProps extends AccessibilityProps {
+    /**
+     * Optional custom style for container
+     */
+    containerStyle?: ViewStyle;
+    /**
+     * Optional size for indicator
+     * Default: "large"
+     */
+    size?: "small" | "large" | number;
+    /**
+     * Optional color for indicator
+     */
+    color?: string;
+    /**
+     * Optional accessibility label
+     * Default: "Loading"
+     */
+    accessibilityLabel?: string;
+}
+export interface LoadingMoreProps extends AccessibilityProps {
+    /**
+     * Optional custom style for container
+     */
+    containerStyle?: ViewStyle;
+    /**
+     * Optional size for indicator
+     * Default: "small"
+     */
+    size?: "small" | "large" | number;
+    /**
+     * Optional color for indicator
+     */
+    color?: string;
+    /**
+     * Optional accessibility label
+     * Default: "Loading more"
+     */
+    accessibilityLabel?: string;
+}

package/dist/infinite-scroll/presentation/hooks/pagination.helper.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Pagination Helper
+ * SOLID: Single Responsibility - Handle pagination operations
+ */
+import type { InfiniteScrollConfig } from "../../domain/types/infinite-scroll-config";
+import type { InfiniteScrollState } from "../../domain/types/infinite-scroll-state";
+/**
+ * Sleep utility for retry delay
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry logic with exponential backoff
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries: number, baseDelay: number): Promise<T>;
+export declare function createInitialState<T>(initialPage: number, totalItems?: number): InfiniteScrollState<T>;
+export declare function isCursorMode<T>(config: InfiniteScrollConfig<T>): config is Extract<InfiniteScrollConfig<T>, {
+    paginationMode: "cursor";
+}>;
+export declare function loadData<T>(config: InfiniteScrollConfig<T>, pageOrCursor: number | string | undefined, pageSize: number, totalItems?: number): Promise<InfiniteScrollState<T>>;
+export declare function loadMoreData<T>(config: InfiniteScrollConfig<T>, state: InfiniteScrollState<T>, pageSize: number): Promise<Partial<InfiniteScrollState<T>>>;

package/dist/infinite-scroll/presentation/hooks/useInfiniteScroll.d.ts

@@ -0,0 +1,8 @@
+/**
+ * useInfiniteScroll Hook
+ *
+ * Supports page-based and cursor-based pagination
+ */
+import type { InfiniteScrollConfig } from "../../domain/types/infinite-scroll-config";
+import type { UseInfiniteScrollReturn } from "../../domain/types/infinite-scroll-return";
+export declare function useInfiniteScroll<T>(config: InfiniteScrollConfig<T>): UseInfiniteScrollReturn<T>;

package/dist/init/createAppInitializer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * App Initializer Factory
+ * Creates a singleton app initializer with ordered module execution
+ */
+import type { AppInitializerConfig, AppInitializerResult, InitModule } from "./types";
+/**
+ * Create an app initializer with singleton pattern
+ *
+ * @example
+ * ```typescript
+ * const initializeApp = createAppInitializer({
+ *   modules: [
+ *     { name: 'firebase', init: initFirebase, critical: true },
+ *     { name: 'auth', init: initAuth, critical: true, dependsOn: ['firebase'] },
+ *     { name: 'subscription', init: initSubscription, dependsOn: ['auth'] },
+ *     { name: 'ai', init: initAI },
+ *   ],
+ * });
+ *
+ * await initializeApp();
+ * ```
+ */
+export declare function createAppInitializer(config: AppInitializerConfig): () => Promise<AppInitializerResult>;
+/**
+ * Create a simple initialization module
+ */
+export declare function createInitModule(name: string, init: () => Promise<void> | void, options?: Partial<Omit<InitModule, "name" | "init">>): InitModule;

package/dist/init/env/createEnvConfig.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Environment Configuration Factory
+ * Creates type-safe environment accessors
+ */
+import type { EnvConfig, EnvAccessor, EnvSourceConfig } from "./types";
+/**
+ * Create environment configuration accessor
+ *
+ * @example
+ * ```typescript
+ * import Constants from 'expo-constants';
+ *
+ * const env = createEnvConfig({
+ *   revenueCat: {
+ *     testStoreKey: 'test_xxx', // Only used in __DEV__
+ *   },
+ *   fal: {
+ *     baseUrl: 'https://fal.run',
+ *   },
+ * }, {
+ *   expoExtra: Constants.expoConfig?.extra,
+ *   processEnv: process.env,
+ * });
+ *
+ * const apiKey = env.getRevenueCatApiKey();
+ * ```
+ */
+export declare function createEnvConfig(config?: EnvConfig, sources?: EnvSourceConfig): EnvAccessor;

package/dist/init/env/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Environment Configuration
+ */
+export { createEnvConfig } from "./createEnvConfig";
+export type { EnvConfig, EnvAccessor, EnvSourceConfig, RevenueCatEnvConfig, FalEnvConfig, FirebaseEnvConfig, } from "./types";