@umituz/react-native-design-system 4.27.13 → 4.27.15

package/src/core/repositories/domain/RepositoryKeyFactory.ts

@@ -0,0 +1,41 @@
+/**
+ * Repository Key Factory
+ *
+ * Generic query key factory for repositories.
+ * Provides consistent query key structure across all repositories.
+ */
+
+import type { QueryKeyFactory, ListParams } from './types';
+
+/**
+ * Create query key factory for a resource
+ *
+ * @param resource - Resource name (e.g., 'users', 'posts')
+ * @returns Query key factory
+ *
+ * @example
+ * ```ts
+ * const keys = createRepositoryKeyFactory('users');
+ *
+ * keys.all(); // ['users']
+ * keys.lists(); // ['users', 'list']
+ * keys.list({ page: 1 }); // ['users', 'list', { page: 1 }]
+ * keys.details(); // ['users', 'detail']
+ * keys.detail(123); // ['users', 'detail', 123]
+ * ```
+ */
+export function createRepositoryKeyFactory(
+  resource: string
+): QueryKeyFactory {
+  return {
+    all: () => [resource] as const,
+
+    lists: () => [resource, 'list'] as const,
+
+    list: (params: ListParams) => [resource, 'list', params] as const,
+
+    details: () => [resource, 'detail'] as const,
+
+    detail: (id: string | number) => [resource, 'detail', id] as const,
+  };
+}

package/src/core/repositories/domain/RepositoryUtils.ts

@@ -0,0 +1,86 @@
+/**
+ * Repository Utilities
+ *
+ * Common utilities for repository implementations.
+ * Provides caching options and helper functions.
+ */
+
+import type { RepositoryOptions, ListParams } from './types';
+
+/**
+ * Default cache options
+ */
+const DEFAULT_CACHE_OPTIONS = {
+  staleTime: 5 * 60 * 1000, // 5 minutes
+  gcTime: 10 * 60 * 1000, // 10 minutes (formerly cacheTime)
+};
+
+/**
+ * Merge repository options with defaults
+ *
+ * @param options - User provided options
+ * @returns Merged options
+ */
+export function mergeRepositoryOptions(
+  options: RepositoryOptions = {}
+): Required<RepositoryOptions> {
+  return {
+    cache: {
+      staleTime: options.cache?.staleTime ?? DEFAULT_CACHE_OPTIONS.staleTime,
+      gcTime: options.cache?.gcTime ?? DEFAULT_CACHE_OPTIONS.gcTime,
+    },
+    debug: options.debug ?? __DEV__,
+  };
+}
+
+/**
+ * Get cache options from repository options
+ *
+ * @param options - Repository options
+ * @returns Cache options with defaults
+ */
+export function getCacheOptions(options: RepositoryOptions): {
+  staleTime: number;
+  gcTime: number;
+} {
+  const merged = mergeRepositoryOptions(options);
+  return {
+    staleTime: merged.cache.staleTime,
+    gcTime: merged.cache.gcTime,
+  };
+}
+
+/**
+ * Normalize list parameters
+ *
+ * @param params - List parameters
+ * @returns Normalized parameters
+ */
+export function normalizeListParams(params: ListParams = {}): ListParams {
+  return {
+    page: params.page ?? 1,
+    limit: params.limit ?? 20,
+    sort: params.sort ?? 'createdAt',
+    filter: params.filter ?? {},
+  };
+}
+
+/**
+ * Create debug logger for repository
+ *
+ * @param resource - Resource name
+ * @param enabled - Enable logging
+ * @returns Logger function
+ */
+export function createRepositoryLogger(
+  resource: string,
+  enabled: boolean = __DEV__
+): (method: string, ...args: unknown[]) => void {
+  if (!enabled) {
+    return () => {};
+  }
+
+  return (method: string, ...args: unknown[]) => {
+    console.log(`[Repository:${resource}] ${method}`, ...args);
+  };
+}

package/src/core/repositories/domain/types.ts

@@ -0,0 +1,59 @@
+/**
+ * Core Repository Domain Types
+ *
+ * Shared types for repository implementations
+ */
+
+/**
+ * Repository options
+ */
+export interface RepositoryOptions {
+  /**
+   * Cache configuration
+   */
+  cache?: {
+    staleTime?: number;
+    gcTime?: number;
+  };
+
+  /**
+   * Enable debug logging
+   */
+  debug?: boolean;
+}
+
+/**
+ * List parameters for fetch operations
+ */
+export interface ListParams {
+  page?: number;
+  limit?: number;
+  sort?: string;
+  filter?: Record<string, unknown>;
+}
+
+/**
+ * Create parameters
+ */
+export interface CreateParams<TVariables> {
+  data: TVariables;
+}
+
+/**
+ * Update parameters
+ */
+export interface UpdateParams<TVariables> {
+  id: string | number;
+  data: TVariables;
+}
+
+/**
+ * Query key factory result
+ */
+export type QueryKeyFactory = {
+  all: () => readonly string[];
+  lists: () => readonly string[];
+  list: (params: ListParams) => readonly string[];
+  details: () => readonly string[];
+  detail: (id: string | number) => readonly string[];
+};

package/src/core/repositories/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Core Repositories Module
+ *
+ * Common utilities and types for repository implementations.
+ * TanStack and Storage repositories remain separate but share these utilities.
+ */
+
+export { createRepositoryKeyFactory } from './domain/RepositoryKeyFactory';
+export type { QueryKeyFactory } from './domain/types';
+
+export {
+  mergeRepositoryOptions,
+  getCacheOptions,
+  normalizeListParams,
+  createRepositoryLogger,
+} from './domain/RepositoryUtils';
+
+export type {
+  RepositoryOptions,
+  ListParams,
+  CreateParams,
+  UpdateParams,
+} from './domain/types';

package/src/device/detection/deviceDetection.ts

@@ -18,7 +18,10 @@ const getDeviceModule = (): typeof import('expo-device') | null => {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     _deviceModule = require('expo-device') as typeof import('expo-device');
     return _deviceModule;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.warn('[deviceDetection] expo-device not available:', error);
+    }
     return null;
   }
 };
@@ -35,7 +38,10 @@ export const getScreenDimensions = () => {
   try {
     validateScreenDimensions(width, height);
     return { width, height };
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.warn('[deviceDetection] Invalid screen dimensions, using fallback:', error);
+    }
     return { width: 414, height: 896 };
   }
 };

package/src/haptics/infrastructure/services/HapticService.ts

@@ -31,7 +31,10 @@ const getHapticsModule = (): typeof import('expo-haptics') | null => {
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     _hapticsModule = require('expo-haptics') as typeof import('expo-haptics');
     return _hapticsModule;
-  } catch {
+  } catch (error) {
+    if (__DEV__) {
+      console.warn('[HapticService] expo-haptics not available:', error);
+    }
     return null;
   }
 };

package/src/index.ts

@@ -36,6 +36,7 @@
  *   /carousel     - Carousel components
  *   /init         - createAppInitializer, createEnvConfig
  *   /device       - DeviceService, useDeviceInfo
+ *   /core         - UnifiedCache, PermissionHandler, Repository utilities
  */
 
 if (__DEV__) {

package/src/media/domain/strategies/CameraPickerStrategy.ts

@@ -0,0 +1,65 @@
+/**
+ * Camera Picker Strategy
+ *
+ * Strategy for capturing images/videos using device camera.
+ */
+
+import * as ImagePicker from 'expo-image-picker';
+import { PermissionManager } from '../../infrastructure/utils/PermissionManager';
+import type { PickerStrategy, LaunchOptions } from './PickerStrategy';
+import type { MediaLibraryPermission } from '../entities/Media';
+
+/**
+ * Camera picker strategy configuration
+ */
+export interface CameraPickerConfig {
+  mediaType: 'images' | 'videos';
+}
+
+/**
+ * Camera picker strategy implementation
+ */
+export class CameraPickerStrategy implements PickerStrategy {
+  readonly name = 'CameraPicker';
+
+  constructor(
+    private config: CameraPickerConfig,
+    private permissionManager: typeof PermissionManager = PermissionManager
+  ) {}
+
+  async getPermission(): Promise<MediaLibraryPermission> {
+    return this.permissionManager.requestCameraPermission();
+  }
+
+  async launch(options: LaunchOptions): Promise<any> {
+    const mediaTypes =
+      this.config.mediaType === 'videos' ? ['videos'] : ['images'];
+
+    const launchOptions: ImagePicker.ImagePickerOptions = {
+      mediaTypes,
+      allowsEditing: options.allowsEditing ?? false,
+      quality: options.quality ?? 1,
+      base64: options.base64 ?? false,
+    };
+
+    // Add aspect ratio for images only
+    if (this.config.mediaType === 'images' && options.aspect) {
+      launchOptions.aspect = options.aspect;
+    }
+
+    // Add video-specific options
+    if (this.config.mediaType === 'videos') {
+      if (options.videoMaxDuration !== undefined) {
+        launchOptions.videoMaxDuration = options.videoMaxDuration;
+      }
+      if (options.videoMaxBitrate !== undefined) {
+        launchOptions.videoMaxBitrate = options.videoMaxBitrate;
+      }
+      if (options.videoQuality) {
+        launchOptions.videoQuality = options.videoQuality;
+      }
+    }
+
+    return ImagePicker.launchCameraAsync(launchOptions);
+  }
+}

package/src/media/domain/strategies/LibraryPickerStrategy.ts

@@ -0,0 +1,54 @@
+/**
+ * Library Picker Strategy
+ *
+ * Strategy for picking images/videos from device gallery.
+ */
+
+import * as ImagePicker from 'expo-image-picker';
+import { PermissionManager } from '../../infrastructure/utils/PermissionManager';
+import { MediaType } from '../entities/Media';
+import type { PickerStrategy, LaunchOptions } from './PickerStrategy';
+import type { MediaLibraryPermission } from '../entities/Media';
+
+/**
+ * Helper to map media type to ImagePicker format
+ */
+function mapMediaType(mediaType?: string): ImagePicker.MediaType[] {
+  if (!mediaType || mediaType === MediaType.ALL) {
+    return ['images', 'videos'];
+  }
+
+  if (mediaType === MediaType.VIDEO) {
+    return ['videos'];
+  }
+
+  return ['images'];
+}
+
+/**
+ * Library picker strategy implementation
+ */
+export class LibraryPickerStrategy implements PickerStrategy {
+  readonly name = 'LibraryPicker';
+
+  constructor(
+    private permissionManager: typeof PermissionManager = PermissionManager
+  ) {}
+
+  async getPermission(): Promise<MediaLibraryPermission> {
+    return this.permissionManager.requestMediaLibraryPermission();
+  }
+
+  async launch(options: LaunchOptions): Promise<any> {
+    return ImagePicker.launchImageLibraryAsync({
+      mediaTypes: mapMediaType(options.mediaTypes),
+      allowsEditing: options.allowsEditing ?? false,
+      allowsMultipleSelection: options.allowsMultipleSelection ?? false,
+      aspect: options.aspect,
+      quality: options.quality ?? 1,
+      selectionLimit: options.selectionLimit ?? 1,
+      base64: options.base64 ?? false,
+      exif: options.exif ?? false,
+    });
+  }
+}

package/src/media/domain/strategies/PickerStrategy.ts

@@ -0,0 +1,61 @@
+/**
+ * Media Picker Strategy Interface
+ *
+ * Strategy pattern for different media picker types.
+ * Allows MediaPickerService to support camera, video, and library pickers polymorphically.
+ */
+
+import type { MediaLibraryPermission } from '../entities/Media';
+
+/**
+ * Common picker options
+ */
+export interface LaunchOptions {
+  allowsEditing?: boolean;
+  quality?: number;
+  aspect?: [number, number];
+  videoMaxDuration?: number;
+  videoMaxBitrate?: number;
+  videoQuality?: 'low' | 'medium' | 'high';
+  base64?: boolean;
+  exif?: boolean;
+  allowsMultipleSelection?: boolean;
+  selectionLimit?: number;
+  mediaTypes?: string;
+  maxFileSizeMB?: number;
+}
+
+/**
+ * Result from picker launch
+ */
+export interface PickerLaunchResult {
+  canceled: boolean;
+  assets?: Array<{
+    uri: string;
+    width?: number;
+    height?: number;
+    type?: 'image' | 'video';
+    duration?: number;
+    fileSize?: number;
+  }>;
+}
+
+/**
+ * Media picker strategy interface
+ */
+export interface PickerStrategy {
+  /**
+   * Get required permission for this picker type
+   */
+  getPermission(): Promise<MediaLibraryPermission>;
+
+  /**
+   * Launch the picker with options
+   */
+  launch(options: LaunchOptions): Promise<PickerLaunchResult>;
+
+  /**
+   * Strategy name for debugging
+   */
+  readonly name: string;
+}

package/src/media/domain/strategies/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Media Picker Strategies
+ *
+ * Strategy pattern implementations for different picker types.
+ */
+
+export { PickerStrategy } from './PickerStrategy';
+export type { LaunchOptions, PickerLaunchResult } from './PickerStrategy';
+
+export { CameraPickerStrategy } from './CameraPickerStrategy';
+export type { CameraPickerConfig } from './CameraPickerStrategy';
+
+export { LibraryPickerStrategy } from './LibraryPickerStrategy';