@umituz/react-native-design-system 4.28.22 → 4.29.0

package/dist/image/presentation/components/editor/StickerPickerSheet.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Presentation - Sticker Picker Sheet
+ */
+import React from 'react';
+import type { BottomSheetModalRef } from '../../../../molecules/bottom-sheet/types/BottomSheet';
+export interface StickerPickerSheetProps {
+    stickers: string[];
+    onSelectSticker: (uri: string) => void;
+    onDismiss: () => void;
+    title?: string;
+    snapPoints?: string[];
+}
+export declare const StickerPickerSheet: React.ForwardRefExoticComponent<StickerPickerSheetProps & React.RefAttributes<BottomSheetModalRef>>;

package/dist/image/presentation/components/editor/TextEditorSheet.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Presentation - Text Editor Sheet
+ */
+import React from 'react';
+import type { BottomSheetModalRef } from '../../../../molecules/bottom-sheet/types/BottomSheet';
+export interface TextEditorSheetProps {
+    text: string;
+    onTextChange: (text: string) => void;
+    color: string;
+    onColorChange: (color: string) => void;
+    fontSize: number;
+    onFontSizeChange: (size: number) => void;
+    fontFamily: string;
+    onFontFamilyChange: (font: string) => void;
+    scale: number;
+    onScaleChange: (scale: number) => void;
+    rotation: number;
+    onRotationChange: (rotation: number) => void;
+    opacity: number;
+    onOpacityChange: (opacity: number) => void;
+    onDelete?: () => void;
+    onDismiss: () => void;
+    snapPoints?: string[];
+    t: (key: string) => string;
+}
+export declare const TextEditorSheet: React.ForwardRefExoticComponent<TextEditorSheetProps & React.RefAttributes<BottomSheetModalRef>>;

package/dist/image/presentation/components/editor/text-editor/TextContentTab.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Text Content Tab - Text input for editor
+ */
+import React from "react";
+import { type TabProps } from "./TextEditorTabs.styles";
+export interface TextContentTabProps extends TabProps {
+    text: string;
+    onTextChange: (t: string) => void;
+}
+export declare const TextContentTab: React.FC<TextContentTabProps>;

package/dist/image/presentation/components/editor/text-editor/TextEditorTabs.styles.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared Styles for Text Editor Tabs
+ */
+export declare const textEditorStyles: {
+    textInput: {
+        borderWidth: number;
+        textAlignVertical: "top";
+    };
+    fontButton: {
+        paddingVertical: number;
+        minWidth: number;
+        alignItems: "center";
+    };
+    colorButton: {
+        width: number;
+        height: number;
+    };
+    sizeButton: {
+        minWidth: number;
+        alignItems: "center";
+    };
+    transformButton: {
+        minWidth: number;
+        alignItems: "center";
+    };
+    deleteButton: {
+        alignSelf: "flex-start";
+    };
+};
+export interface TabProps {
+    t: (key: string) => string;
+}

package/dist/image/presentation/components/editor/text-editor/TextStyleTab.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Text Style Tab - Font, color, size selection
+ */
+import React from "react";
+import { type TabProps } from "./TextEditorTabs.styles";
+export interface TextStyleTabProps extends TabProps {
+    fontSize: number;
+    setFontSize: (s: number) => void;
+    color: string;
+    setColor: (c: string) => void;
+    fontFamily: string;
+    setFontFamily: (f: string) => void;
+}
+export declare const TextStyleTab: React.FC<TextStyleTabProps>;

package/dist/image/presentation/components/editor/text-editor/TextTransformTab.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Text Transform Tab - Scale, rotation, opacity, delete
+ */
+import React from "react";
+import type { TabProps } from "./TextEditorTabs.styles";
+export interface TextTransformTabProps extends TabProps {
+    scale: number;
+    setScale: (s: number) => void;
+    rotation: number;
+    setRotation: (r: number) => void;
+    opacity: number;
+    setOpacity: (o: number) => void;
+    onDelete?: () => void;
+}
+export declare const TextTransformTab: React.FC<TextTransformTabProps>;

package/dist/image/presentation/components/editor/text-editor/components/TransformButtonRow.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Transform Button Row Component
+ *
+ * Reusable horizontal scrollable row of transform buttons.
+ */
+import React from "react";
+import { type StyleProp, type ViewStyle } from "react-native";
+interface TransformButton {
+    value: number;
+    label: string;
+}
+interface TransformButtonRowProps {
+    title: string;
+    buttons: TransformButton[];
+    selectedValue: number;
+    onSelect: (value: number) => void;
+    formatLabel?: (value: number) => string;
+    formatTitle?: (selectedValue: number) => string;
+    style?: StyleProp<ViewStyle>;
+}
+export declare const TransformButtonRow: React.FC<TransformButtonRowProps>;
+interface DeleteButtonProps {
+    onPress: () => void;
+    label?: string;
+}
+export declare const DeleteButton: React.FC<DeleteButtonProps>;
+export {};

package/dist/image/presentation/components/editor/text-editor/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Text Editor Tabs - Barrel export
+ */
+export { TextContentTab } from "./TextContentTab";
+export type { TextContentTabProps } from "./TextContentTab";
+export { TextStyleTab } from "./TextStyleTab";
+export type { TextStyleTabProps } from "./TextStyleTab";
+export { TextTransformTab } from "./TextTransformTab";
+export type { TextTransformTabProps } from "./TextTransformTab";
+export { textEditorStyles, type TabProps } from "./TextEditorTabs.styles";

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

@@ -0,0 +1,49 @@
+/**
+ * Presentation - Image Hook
+ *
+ * Aggregator hook combining transformation and conversion capabilities
+ */
+export declare const useImage: () => {
+    isProcessing: boolean;
+    error: string | null;
+    extractMetadata: (uri: string, options?: import("../..").ImageMetadataExtractionOptions) => Promise<import("../..").ImageMetadataExtended | null>;
+    getBasicInfo: (uri: string) => Promise<{
+        format: string;
+        size: number;
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    } | null>;
+    hasMetadata: (uri: string) => Promise<boolean | null>;
+    isExtracting: boolean;
+    metadataError: string | null;
+    autoEnhance: (uri: string, options?: import("../..").AutoEnhancementOptions) => Promise<import("../..").EnhancementResult | null>;
+    enhancePortrait: (uri: string) => Promise<import("../..").ImageManipulationResult | null>;
+    enhanceLandscape: (uri: string) => Promise<import("../..").ImageManipulationResult | null>;
+    analyzeImage: (uri: string) => Promise<import("../..").ImageQualityMetrics | null>;
+    isEnhancing: boolean;
+    enhancementError: string | null;
+    processBatch: (operations: import("../..").BatchOperation[], options?: import("../..").BatchProcessingOptions) => Promise<import("../..").BatchProcessingResult | null>;
+    resizeBatch: (uris: string[], width?: number, height?: number, options?: import("../..").BatchProcessingOptions & {
+        saveOptions?: Record<string, unknown>;
+    }) => Promise<import("../..").BatchProcessingResult | null>;
+    compressBatch: (uris: string[], quality?: number, options?: import("../..").BatchProcessingOptions) => Promise<import("../..").BatchProcessingResult | null>;
+    isBatchProcessing: boolean;
+    batchError: string | null;
+    compress: (uri: string, quality?: number) => Promise<import("../..").ImageManipulationResult | null>;
+    convertFormat: (uri: string, format: import("../..").SaveFormat, quality?: number) => Promise<import("../..").ImageManipulationResult | null>;
+    createThumbnail: (uri: string, size?: number, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    saveImage: (uri: string, filename?: string) => Promise<string | null>;
+    isConverting: boolean;
+    conversionError: string | null;
+    resize: (uri: string, width?: number, height?: number, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    crop: (uri: string, cropArea: import("../..").ImageCropArea, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    rotate: (uri: string, degrees: number, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    flip: (uri: string, flipParams: import("../..").ImageFlipOptions, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    manipulate: (uri: string, action: import("../..").ImageManipulateAction, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    resizeToFit: (uri: string, maxWidth: number, maxHeight: number, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    cropToSquare: (uri: string, width: number, height: number, options?: import("../..").ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    isTransforming: boolean;
+    transformError: string | null;
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Presentation - Image Batch Hook
+ */
+import { type BatchProcessingOptions } from '../../infrastructure/services/ImageBatchService';
+import type { BatchOperation } from '../../infrastructure/types/BatchTypes';
+export declare const useImageBatch: () => {
+    processBatch: (operations: BatchOperation[], options?: BatchProcessingOptions) => Promise<import("../..").BatchProcessingResult | null>;
+    resizeBatch: (uris: string[], width?: number, height?: number, options?: BatchProcessingOptions & {
+        saveOptions?: Record<string, unknown>;
+    }) => Promise<import("../..").BatchProcessingResult | null>;
+    compressBatch: (uris: string[], quality?: number, options?: BatchProcessingOptions) => Promise<import("../..").BatchProcessingResult | null>;
+    isBatchProcessing: boolean;
+    batchError: string | null;
+};

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

@@ -0,0 +1,9 @@
+import type { ImageSaveOptions, SaveFormat } from '../../domain/entities/ImageTypes';
+export declare const useImageConversion: () => {
+    compress: (uri: string, quality?: number) => Promise<import("../..").ImageManipulationResult | null>;
+    convertFormat: (uri: string, format: SaveFormat, quality?: number) => Promise<import("../..").ImageManipulationResult | null>;
+    createThumbnail: (uri: string, size?: number, options?: ImageSaveOptions) => Promise<import("../..").ImageManipulationResult | null>;
+    saveImage: (uri: string, filename?: string) => Promise<string | null>;
+    isConverting: boolean;
+    conversionError: string | null;
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Presentation - Image Enhance Hook
+ */
+import { type AutoEnhancementOptions } from '../../infrastructure/services/ImageEnhanceService';
+export declare const useImageEnhance: () => {
+    autoEnhance: (uri: string, options?: AutoEnhancementOptions) => Promise<import("../..").EnhancementResult | null>;
+    enhancePortrait: (uri: string) => Promise<import("../..").ImageManipulationResult | null>;
+    enhanceLandscape: (uri: string) => Promise<import("../..").ImageManipulationResult | null>;
+    analyzeImage: (uri: string) => Promise<import("../..").ImageQualityMetrics | null>;
+    isEnhancing: boolean;
+    enhancementError: string | null;
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Presentation - Image Gallery Hook
+ */
+import type { ImageViewerItem, ImageGalleryOptions } from '../../domain/entities/ImageTypes';
+export interface UseImageGalleryReturn {
+    visible: boolean;
+    currentIndex: number;
+    images: ImageViewerItem[];
+    open: (images: ImageViewerItem[] | string[], startIndex?: number, options?: ImageGalleryOptions) => void;
+    close: () => void;
+    setIndex: (index: number) => void;
+    options: ImageGalleryOptions;
+}
+export declare const useImageGallery: (defaultOptions?: ImageGalleryOptions) => UseImageGalleryReturn;

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

@@ -0,0 +1,18 @@
+/**
+ * Presentation - Image Metadata Hook
+ */
+import { type ImageMetadataExtractionOptions } from '../../infrastructure/services/ImageMetadataService';
+export declare const useImageMetadata: () => {
+    extractMetadata: (uri: string, options?: ImageMetadataExtractionOptions) => Promise<import("../..").ImageMetadataExtended | null>;
+    getBasicInfo: (uri: string) => Promise<{
+        format: string;
+        size: number;
+        dimensions: {
+            width: number;
+            height: number;
+        };
+    } | null>;
+    hasMetadata: (uri: string) => Promise<boolean | null>;
+    isExtracting: boolean;
+    metadataError: string | null;
+};

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

@@ -0,0 +1,10 @@
+/**
+ * Presentation - Image Operation Hook
+ *
+ * Generic state management for async image operations
+ */
+export declare const useImageOperation: () => {
+    isProcessing: boolean;
+    error: string | null;
+    execute: <T>(operation: () => Promise<T>, errorMessage: string) => Promise<T | null>;
+};

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,41 @@
+/**
+ * @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, ChatOnboardingScreen (chat-based)
+ *   /gallery      - gallerySaveService
+ *   /carousel     - Carousel components
+ *   /init         - createAppInitializer, createEnvConfig
+ *   /device       - DeviceService, useDeviceInfo
+ *   /core         - UnifiedCache, PermissionHandler, Repository utilities
+ */
+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;