feat: adding required types, and the iOS haptic module

Author: Mhp23

ios/Haptics.h

@@ -1,5 +1,16 @@
 #import <HapticsSpec/HapticsSpec.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
 
 @interface Haptics : NSObject <NativeHapticsSpec>
 
+@property (nonatomic, strong) UISelectionFeedbackGenerator *selectionGenerator;
+@property (nonatomic, strong) UINotificationFeedbackGenerator *notificationGenerator;
+
+@property (nonatomic, strong) NSDictionary<NSString *, NSNumber *> *impactStyles;
+@property (nonatomic, strong) NSDictionary<NSString *, NSNumber *> *notificationTypes;
+
 @end
+
+NS_ASSUME_NONNULL_END

ios/Haptics.mm

@@ -1,8 +1,87 @@
 #import "Haptics.h"
+#import <React/RCTLog.h>
 
 @implementation Haptics
+
 RCT_EXPORT_MODULE()
 
++ (BOOL)requiresMainQueueSetup
+{
+  return YES;
+}
+
+- (instancetype)init
+{
+    self = [super init];
+    if (self) {
+        _notificationGenerator = [UINotificationFeedbackGenerator new];
+        [_notificationGenerator prepare];
+        
+        _selectionGenerator = [UISelectionFeedbackGenerator new];
+        [_selectionGenerator prepare];
+        
+        _impactStyles = @{
+            @"light": @(UIImpactFeedbackStyleLight),
+            @"medium": @(UIImpactFeedbackStyleMedium),
+            @"heavy": @(UIImpactFeedbackStyleHeavy),
+            @"soft": @(UIImpactFeedbackStyleSoft),
+            @"rigid": @(UIImpactFeedbackStyleRigid)
+        };
+
+        _notificationTypes = @{
+            @"success": @(UINotificationFeedbackTypeSuccess),
+            @"warning": @(UINotificationFeedbackTypeWarning),
+            @"error": @(UINotificationFeedbackTypeError)
+        };
+    }
+    return self;
+}
+
+- (void)impact:(NSString *)style
+        resolve:(nonnull RCTPromiseResolveBlock)resolve
+        reject:(nonnull RCTPromiseRejectBlock)reject
+{
+  NSNumber *styleValue = self.impactStyles[style];
+
+  if (!styleValue) {
+    reject(@"E_INVALID_STYLE", [NSString stringWithFormat:@"Invalid impact style '%@'", style], nil);
+    return;
+  }
+  UIImpactFeedbackGenerator *generator = [[UIImpactFeedbackGenerator alloc]
+                                          initWithStyle:(UIImpactFeedbackStyle)styleValue.integerValue];
+  [generator prepare];
+  [generator impactOccurred];
+
+  resolve(nil);
+}
+
+- (void)notification:(NSString *)type
+        resolve:(nonnull RCTPromiseResolveBlock)resolve
+        reject:(nonnull RCTPromiseRejectBlock)reject
+{
+  NSNumber *typeValue = self.notificationTypes[type];
+
+  if (!typeValue) {
+    reject(@"E_INVALID_TYPE", [NSString stringWithFormat:@"Invalid notification type '%@'", type], nil);
+    return;
+  }
+  [self.notificationGenerator notificationOccurred:(UINotificationFeedbackType)typeValue.integerValue];
+  resolve(nil);
+}
+
+- (void)selection:(nonnull RCTPromiseResolveBlock)resolve
+        reject:(nonnull RCTPromiseRejectBlock)reject {
+  [self.selectionGenerator prepare];
+  [self.selectionGenerator selectionChanged];
+  resolve(nil);
+}
+
+- (void)androidHaptics:(nonnull NSString *)type
+        resolve:(nonnull RCTPromiseResolveBlock)resolve
+        reject:(nonnull RCTPromiseRejectBlock)reject {
+  resolve(nil);
+}
+
 - (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
     (const facebook::react::ObjCTurboModule::InitParams &)params
 {

src/NativeHaptics.ts

@@ -1,6 +1,53 @@
 import type {TurboModule} from 'react-native';
 import {TurboModuleRegistry} from 'react-native';
 
-export interface Spec extends TurboModule {}
+export type NotificationFeedback = 'error' | 'success' | 'warning';
+export type ImpactFeedback = 'soft' | 'light' | 'rigid' | 'heavy' | 'medium';
+export type AndroidHapticsFeedback =
+  | 'reject'
+  | 'confirm'
+  | 'toggle-on'
+  | 'no-haptics'
+  | 'long-press'
+  | 'drag-start'
+  | 'clock-tick'
+  | 'toggle-off'
+  | 'virtual-key'
+  | 'gesture-end'
+  | 'keyboard-tap'
+  | 'segment-tick'
+  | 'gesture-start'
+  | 'context-click'
+  | 'keyboard-press'
+  | 'text-handle-move'
+  | 'keyboard-release'
+  | 'virtual-key-release'
+  | 'segment-frequent-tick';
+
+export interface Spec extends TurboModule {
+  /**
+   * Triggers haptic feedback based on the provided selection feedback type.
+   * @returns A promise that resolves when the haptic feedback is completed.
+   */
+  selection(): Promise<void>;
+  /**
+   * Triggers haptic feedback based on the provided impact style.
+   * @param style The type of impact feedback to trigger.
+   * @returns A promise that resolves when the haptic feedback is completed.
+   */
+  impact(style: ImpactFeedback): Promise<void>;
+  /**
+   * Triggers haptic feedback based on the provided selection feedback type.
+   * @platform android
+   * @returns A promise that resolves when the haptic feedback is completed.
+   */
+  androidHaptics(type: AndroidHapticsFeedback): Promise<void>;
+  /**
+   * Triggers haptic feedback based on the provided notification type.
+   * @param type The type of notification feedback to trigger.
+   * @returns A promise that resolves when the haptic feedback is completed.
+   */
+  notification(type: NotificationFeedback): Promise<void>;
+}
 
 export default TurboModuleRegistry.getEnforcing<Spec>('Haptics');

src/index.tsx

@@ -1 +1,44 @@
-export {default as Haptics} from './NativeHaptics';
+import NativeHaptics, {
+  type ImpactFeedback,
+  type NotificationFeedback,
+  type AndroidHapticsFeedback,
+} from './NativeHaptics';
+import {Platform} from 'react-native';
+
+/**
+ * Triggers haptic feedback based on the provided impact style.
+ * @param style The type of impact feedback to trigger.
+ * @returns A promise that resolves when the haptic feedback is completed.
+ */
+const impact = async (style: ImpactFeedback) => {
+  await NativeHaptics.impact(style);
+};
+/**
+ * Triggers haptic feedback based on the provided notification type.
+ * @param type The type of notification feedback to trigger.
+ * @returns A promise that resolves when the haptic feedback is completed.
+ */
+const notification = async (type: NotificationFeedback) => {
+  await NativeHaptics.notification(type);
+};
+/**
+ * Triggers haptic feedback based on the provided selection feedback type.
+ * @platform android
+ * @returns A promise that resolves when the haptic feedback is completed.
+ */
+const androidHaptics = async (type: AndroidHapticsFeedback) => {
+  if (Platform.OS !== 'android') {
+    return;
+  }
+  await NativeHaptics.androidHaptics(type);
+};
+/**
+ * Triggers haptic feedback based on the provided selection feedback type.
+ * @returns A promise that resolves when the haptic feedback is completed.
+ */
+const selection = async () => {
+  await NativeHaptics.selection();
+};
+
+const Haptics = {impact, notification, androidHaptics, selection};
+export default Haptics;