@umituz/react-native-haptics 1.0.5 → 1.0.7

package/README.md

@@ -21,8 +21,12 @@ npm install @umituz/react-native-haptics
 - ✅ Selection feedback (pickers, sliders)
 - ✅ Custom haptic patterns
 - ✅ Convenience methods for common interactions
+- ✅ Type guards for runtime type safety
+- ✅ Throttle mechanism (50ms minimum interval)
+- ✅ Development-mode error logging
 - ✅ Silent failure (no crashes if unsupported)
 - ✅ Platform-agnostic (iOS + Android)
+- ✅ Performance optimized (useMemo, useCallback)
 
 ## Usage
 
@@ -91,6 +95,28 @@ await HapticService.buttonPress();
 await HapticService.success();
 ```
 
+### Type Guards
+
+```typescript
+import { isImpactStyle, isNotificationType, isHapticPattern } from '@umituz/react-native-haptics';
+
+// Validate impact style
+if (isImpactStyle(userInput)) {
+  // TypeScript knows userInput is ImpactStyle here
+  haptics.impact(userInput);
+}
+
+// Validate notification type
+if (isNotificationType(type)) {
+  haptics.notification(type);
+}
+
+// Validate haptic pattern
+if (isHapticPattern(pattern)) {
+  haptics.pattern(pattern);
+}
+```
+
 ## Common Patterns
 
 - `buttonPress()` - Light impact
@@ -114,7 +140,17 @@ await HapticService.success();
 
 ### Utilities
 
-- `HapticUtils`: Utility functions for haptic pattern management
+- `HAPTIC_CONSTANTS`: Constants for default haptic styles
+- `isImpactStyle()`: Type guard for ImpactStyle validation
+- `isNotificationType()`: Type guard for NotificationType validation
+- `isHapticPattern()`: Type guard for HapticPattern validation
+
+## Performance
+
+- **Throttle**: 50ms minimum interval between haptic feedback to prevent spam
+- **Memoization**: Hook return value is memoized with useMemo
+- **Callback optimization**: All callbacks use useCallback to prevent re-renders
+- **Development logging**: Errors are logged only in development mode (__DEV__)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-haptics",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Haptic feedback (vibration) for React Native using expo-haptics with impact, notification, and selection feedback patterns",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/domain/entities/Haptic.ts

@@ -22,9 +22,9 @@ export type NotificationType = 'Success' | 'Warning' | 'Error';
  * Haptic patterns for common interactions
  */
 export type HapticPattern =
-  | 'Success'
-  | 'Warning'
-  | 'Error'
+  | 'success'
+  | 'warning'
+  | 'error'
   | 'selection';
 
 /**
@@ -38,14 +38,29 @@ export const HAPTIC_CONSTANTS = {
 } as const;
 
 /**
- * Haptic utilities
- * Simplified - pattern handling moved to HapticService
+ * Type guards for runtime type safety
  */
-export class HapticUtils {
-  /**
-   * Get default impact style for common patterns
-   */
-  static getDefaultImpact(): ImpactStyle {
-    return 'Light';
-  }
+
+/**
+ * Check if value is a valid ImpactStyle
+ */
+export function isImpactStyle(value: unknown): value is ImpactStyle {
+  return typeof value === 'string' &&
+         ['Light', 'Medium', 'Heavy'].includes(value);
+}
+
+/**
+ * Check if value is a valid NotificationType
+ */
+export function isNotificationType(value: unknown): value is NotificationType {
+  return typeof value === 'string' &&
+         ['Success', 'Warning', 'Error'].includes(value);
+}
+
+/**
+ * Check if value is a valid HapticPattern
+ */
+export function isHapticPattern(value: unknown): value is HapticPattern {
+  return typeof value === 'string' &&
+         ['success', 'warning', 'error', 'selection'].includes(value);
 }

package/src/index.ts

@@ -163,7 +163,9 @@ export type {
 
 export {
   HAPTIC_CONSTANTS,
-  HapticUtils,
+  isImpactStyle,
+  isNotificationType,
+  isHapticPattern,
 } from './domain/entities/Haptic';
 
 // ============================================================================

package/src/infrastructure/services/HapticService.ts

@@ -10,6 +10,16 @@
 
 import * as Haptics from 'expo-haptics';
 import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/entities/Haptic';
+import { isImpactStyle, isNotificationType, isHapticPattern } from '../../domain/entities/Haptic';
+
+/**
+ * Log error in development mode only
+ */
+function logError(method: string, error: unknown): void {
+  if (process.env.NODE_ENV === 'development') {
+    console.error(`[HapticService.${method}]`, error);
+  }
+}
 
 
 /**
@@ -27,7 +37,7 @@ export class HapticService {
         Haptics.ImpactFeedbackStyle.Heavy
       );
     } catch (error) {
-      // Silent fail - haptics not critical
+      logError('impact', error);
     }
   }
 
@@ -42,7 +52,7 @@ export class HapticService {
         Haptics.NotificationFeedbackType.Error
       );
     } catch (error) {
-      // Silent fail
+      logError('notification', error);
     }
   }
 
@@ -53,7 +63,7 @@ export class HapticService {
     try {
       await Haptics.selectionAsync();
     } catch (error) {
-      // Silent fail
+      logError('selection', error);
     }
   }
 
@@ -62,21 +72,24 @@ export class HapticService {
    */
   static async pattern(pattern: HapticPattern): Promise<void> {
     try {
-      if (pattern === 'selection') {
-        await HapticService.selection();
-        return;
-      }
-
-      // Success, Warning, Error map to notification feedback
-      if (pattern === 'Success' || pattern === 'Warning' || pattern === 'Error') {
-        await HapticService.notification(pattern as NotificationType);
-        return;
+      switch (pattern) {
+        case 'selection':
+          await HapticService.selection();
+          break;
+        case 'success':
+          await HapticService.notification('Success');
+          break;
+        case 'warning':
+          await HapticService.notification('Warning');
+          break;
+        case 'error':
+          await HapticService.notification('Error');
+          break;
+        default:
+          await HapticService.impact('Light');
       }
-
-      // Default to light impact
-      await HapticService.impact('Light');
     } catch (error) {
-      // Silent fail
+      logError('pattern', error);
     }
   }
 
@@ -88,15 +101,15 @@ export class HapticService {
   }
 
   static async success(): Promise<void> {
-    await HapticService.pattern('Success');
+    await HapticService.pattern('success');
   }
 
   static async error(): Promise<void> {
-    await HapticService.pattern('Error');
+    await HapticService.pattern('error');
   }
 
   static async warning(): Promise<void> {
-    await HapticService.pattern('Warning');
+    await HapticService.pattern('warning');
   }
 
   static async delete(): Promise<void> {

package/src/presentation/hooks/useHaptics.ts

@@ -8,10 +8,16 @@
  * @layer presentation/hooks
  */
 
-import { useCallback } from 'react';
+import { useCallback, useRef, useMemo } from 'react';
 import { HapticService } from '../../infrastructure/services/HapticService';
 import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/entities/Haptic';
 
+/**
+ * Minimum interval between haptic feedback (ms)
+ * Prevents spam and improves UX
+ */
+const THROTTLE_INTERVAL = 50;
+
 /**
  * useHaptics hook for haptic feedback
  *
@@ -45,70 +51,96 @@ import type { ImpactStyle, NotificationType, HapticPattern } from '../../domain/
  * ```
  */
 export const useHaptics = () => {
+  const lastExecutionRef = useRef<number>(0);
+
+  /**
+   * Check if enough time has passed since last haptic
+   */
+  const canExecute = useCallback((): boolean => {
+    const now = Date.now();
+    if (now - lastExecutionRef.current < THROTTLE_INTERVAL) {
+      return false;
+    }
+    lastExecutionRef.current = now;
+    return true;
+  }, []);
+
   /**
    * Trigger impact feedback (light, medium, heavy)
    */
   const impact = useCallback(async (style: ImpactStyle = 'Light') => {
+    if (!canExecute()) return;
     await HapticService.impact(style);
-  }, []);
+  }, [canExecute]);
 
   /**
    * Trigger notification feedback (success, warning, error)
    */
   const notification = useCallback(async (type: NotificationType) => {
+    if (!canExecute()) return;
     await HapticService.notification(type);
-  }, []);
+  }, [canExecute]);
 
   /**
    * Trigger selection feedback (for pickers, sliders)
    */
   const selection = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.selection();
-  }, []);
+  }, [canExecute]);
 
   /**
    * Trigger custom haptic pattern
    */
   const pattern = useCallback(async (patternType: HapticPattern) => {
+    if (!canExecute()) return;
     await HapticService.pattern(patternType);
-  }, []);
+  }, [canExecute]);
 
   /**
    * Common haptic patterns (convenience methods)
    */
   const buttonPress = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.buttonPress();
-  }, []);
+  }, [canExecute]);
 
   const success = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.success();
-  }, []);
+  }, [canExecute]);
 
   const error = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.error();
-  }, []);
+  }, [canExecute]);
 
   const warning = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.warning();
-  }, []);
+  }, [canExecute]);
 
   const deleteItem = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.delete();
-  }, []);
+  }, [canExecute]);
 
   const refresh = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.refresh();
-  }, []);
+  }, [canExecute]);
 
   const selectionChange = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.selectionChange();
-  }, []);
+  }, [canExecute]);
 
   const longPress = useCallback(async () => {
+    if (!canExecute()) return;
     await HapticService.longPress();
-  }, []);
+  }, [canExecute]);
 
-  return {
+  return useMemo(() => ({
     // Generic methods
     impact,
     notification,
@@ -124,5 +156,18 @@ export const useHaptics = () => {
     refresh,
     selectionChange,
     longPress,
-  };
+  }), [
+    impact,
+    notification,
+    selection,
+    pattern,
+    buttonPress,
+    success,
+    error,
+    warning,
+    deleteItem,
+    refresh,
+    selectionChange,
+    longPress,
+  ]);
 };