@symbiote-native/haptics 0.0.1 → 0.2.0

package/README.md

@@ -1,18 +1,116 @@
 # @symbiote-native/haptics
 
-**Status: skeleton only — not implemented, published early to reserve the npm name.**
+Port of [`expo-haptics`](https://docs.expo.dev/versions/latest/sdk/haptics/) for
+[SymbioteNative](../../README.md) — impact/notification/selection vibration feedback via iOS's
+Taptic Engine and Android's Vibrator API, plus a direct Android haptics-engine path
+(`performAndroidHapticsAsync`). Built the same way as
+[`@symbiote-native/local-auth`](../local-auth): an `expo-modules-core`-based wrapper, free
+functions with no per-instance state and no event stream. Reachable from every adapter — React,
+Vue, Angular — not just React.
 
-Planned port of [`expo-haptics`](https://docs.expo.dev/versions/latest/sdk/haptics/) for
-[SymbioteNative](../../README.md) — vibration/haptic feedback via iOS's Taptic Engine and
-Android's Vibrator API, reachable from every adapter (React, Vue, Angular), not just React.
-Nothing is wired up yet: no `src/`, no dependencies, no build.
+## Install
 
-## Planned API
+```bash
+npm install @symbiote-native/haptics
+```
+
+`expo-haptics` and `expo-modules-core` come along as regular, exact-pinned dependencies — never
+install either yourself, and never add the `expo` meta-package (it bundles its own Metro/Babel
+pipeline that conflicts with this project's own).
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-haptics`' native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs`/podspec mechanism — this needs
+wiring into the native host app **once**, covering this package and every other
+`expo-modules-core` package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics live in the `symbiote-expo-native-module` project skill. Reference
+implementation: `examples/expo-react/ios/Podfile` and
+`examples/expo-react/android/app/src/main/java/com/canaryexpo/MainApplication.kt` (registers
+`HapticsModule` as `"ExpoHaptics"`).
+
+No permission or `Info.plist`/`AndroidManifest.xml` entry is needed on either platform — haptic
+feedback requires none.
+
+## Shape
 
-Free functions, no event stream, no per-instance state — upstream ships four async functions
-and three enums, no subscribable feedback source. Signatures below are read straight from
-`expo-haptics`'s `Haptics.ts`/`Haptics.types.ts` and are forward-looking reference only; nothing
-here exists yet.
+```
+src/core/     notificationAsync / impactAsync / selectionAsync / performAndroidHapticsAsync,
+              plus NotificationFeedbackType / ImpactFeedbackStyle / AndroidHaptics.
+              native-module.ts resolves the ExpoHaptics native module via
+              expo-modules-core's requireNativeModule.
+src/react/    @symbiote-native/haptics/react   — plain re-export of core.
+src/vue/      @symbiote-native/haptics/vue     — plain re-export of core.
+src/angular/  @symbiote-native/haptics/angular — plain re-export of core.
+```
+
+Upstream ships four async functions and three enums, not a subscribable sensor — there's
+nothing per-framework to add, so all three adapter entry points are identical re-exports of
+`core`.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/HapticsScreen.tsx
+import { impactAsync, ImpactFeedbackStyle, notificationAsync, NotificationFeedbackType, selectionAsync } from '@symbiote-native/haptics';
+
+function HapticsScreen() {
+  return (
+    <>
+      <ActionButton title="Medium" onPress={() => impactAsync(ImpactFeedbackStyle.Medium)} />
+      <ActionButton title="Success" onPress={() => notificationAsync(NotificationFeedbackType.Success)} />
+      <ActionButton title="Selection" onPress={() => selectionAsync()} />
+    </>
+  );
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/HapticsScreen.vue -->
+<script setup lang="ts">
+import { impactAsync, ImpactFeedbackStyle, notificationAsync, NotificationFeedbackType, selectionAsync } from '@symbiote-native/haptics';
+
+function fireImpact(style: ImpactFeedbackStyle): void {
+  void impactAsync(style);
+}
+</script>
+<template>
+  <ActionButton title="Medium" :onPress="() => fireImpact(ImpactFeedbackStyle.Medium)" />
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/HapticsScreen.ts
+import { Component } from '@angular/core';
+import { impactAsync, ImpactFeedbackStyle, notificationAsync, NotificationFeedbackType } from '@symbiote-native/haptics';
+
+@Component({
+  selector: 'HapticsScreen',
+  template: `<ActionButton title="Medium" (press)="handleImpact()"></ActionButton>`,
+})
+export class HapticsScreen {
+  handleImpact(): void {
+    impactAsync(ImpactFeedbackStyle.Medium);
+  }
+}
+```
+
+Every call is fire-and-forget (no result to await) — a real device is needed to feel the
+feedback, a simulator produces none. Android also gets `performAndroidHapticsAsync`, which
+drives the device haptics engine directly instead of `impactAsync`'s Vibrator simulation; it
+no-ops on every other platform.
+
+## API
+
+Free functions, no event stream, no per-instance state:
 
 ```ts
 notificationAsync(type?: NotificationFeedbackType): Promise<void>
@@ -28,16 +126,27 @@ performAndroidHapticsAsync(type: AndroidHaptics): Promise<void>
 // Android only — no-ops on other platforms. Uses the device haptics engine directly, unlike the Vibrator-based impactAsync.
 ```
 
-Plus the `NotificationFeedbackType`, `ImpactFeedbackStyle`, and `AndroidHaptics` enums ported
-from upstream's `Haptics.types.ts`.
+Plus `NotificationFeedbackType`, `ImpactFeedbackStyle`, `AndroidHaptics` — ported verbatim from
+upstream's `Haptics.types.ts`.
+
+```ts
+import { impactAsync, ImpactFeedbackStyle } from '@symbiote-native/haptics';
+// or the framework-scoped entry points — identical surface, re-exported verbatim:
+import { impactAsync } from '@symbiote-native/haptics/react';
+import { impactAsync } from '@symbiote-native/haptics/vue';
+import { impactAsync } from '@symbiote-native/haptics/angular';
+```
+
+## Test it
 
-## Reference
+No Fabric/Descriptor angle at all — haptics is a pure async-function surface, never a view.
+Tests exercise the JS layer via a fake native module in place of the real
+`requireNativeModule` resolution (`vitest`, `src/**/*.test.{ts,tsx}`) — no `installFabric()`, no
+ViewConfig. Native rendering itself is verified on-device (see the parent
+[README](../../README.md)).
 
-- [`@symbiote-native/local-auth`](../local-auth) — the nearest already-implemented sibling
-  package; shows the shape this package will take once it moves past skeleton (three-entry
-  `exports` map, `core`/`react`/`vue`/`angular` split, `expo-modules-core` dependency).
-- The `symbiote-expo-native-module` project skill
-  (`../../.claude/skills/symbiote-expo-native-module/SKILL.md`) — the real wrapping mechanics
-  (depend on `expo-modules-core` only, never the `expo` meta-package; port the JS into `core/`
-  rather than importing upstream's; how autolinking picks up the native module) that will apply
-  when implementation starts.
+Native wiring for this package is done across all four `examples/expo-*` canary apps (Android
+3-layer registration in each app's `build.gradle`/`MainApplication.kt`/`AndroidManifest.xml`,
+plus iOS Podfile/pod install) — not yet ported into the plain, non-Expo public canaries
+(`examples/react`, `examples/vue-sfc`, `examples/vue-tsx`, `examples/angular`), and no
+on-device/simulator automated (Detox) smoke test exists yet, only manual verification.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/haptics/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core/index.js';

package/build/core/haptics.d.ts

@@ -0,0 +1,24 @@
+import { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+/**
+ * The kind of notification response used in the feedback. On Android it is simulated using
+ * `Vibrator`; on iOS it maps directly to `UINotificationFeedbackType`.
+ */
+export declare function notificationAsync(type?: NotificationFeedbackType): Promise<void>;
+/**
+ * A collision indicator. On Android it is simulated using `Vibrator`; on iOS it maps directly to
+ * `UIImpactFeedbackStyle`.
+ * @see Android's `Vibrator` API is not recommended for haptics feedback — prefer
+ * `performAndroidHapticsAsync`, which drives the device haptics engine directly and does not
+ * require the `VIBRATE` permission.
+ */
+export declare function impactAsync(style?: ImpactFeedbackStyle): Promise<void>;
+/**
+ * Lets the user know a selection change has been registered.
+ */
+export declare function selectionAsync(): Promise<void>;
+/**
+ * Uses the device haptics engine directly to provide physical feedback to the user. A no-op on
+ * every platform except Android.
+ * @platform android
+ */
+export declare function performAndroidHapticsAsync(type: AndroidHaptics): Promise<void>;

package/build/core/haptics.js

@@ -0,0 +1,50 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoHaptics } from './native-module.js';
+import { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types.js';
+const NATIVE_MODULE_NAME = 'expo-haptics';
+/**
+ * The kind of notification response used in the feedback. On Android it is simulated using
+ * `Vibrator`; on iOS it maps directly to `UINotificationFeedbackType`.
+ */
+export async function notificationAsync(type = NotificationFeedbackType.Success) {
+    if (!expoHaptics.notificationAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'notificationAsync');
+    }
+    await expoHaptics.notificationAsync(type);
+}
+/**
+ * A collision indicator. On Android it is simulated using `Vibrator`; on iOS it maps directly to
+ * `UIImpactFeedbackStyle`.
+ * @see Android's `Vibrator` API is not recommended for haptics feedback — prefer
+ * `performAndroidHapticsAsync`, which drives the device haptics engine directly and does not
+ * require the `VIBRATE` permission.
+ */
+export async function impactAsync(style = ImpactFeedbackStyle.Medium) {
+    if (!expoHaptics.impactAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'impactAsync');
+    }
+    await expoHaptics.impactAsync(style);
+}
+/**
+ * Lets the user know a selection change has been registered.
+ */
+export async function selectionAsync() {
+    if (!expoHaptics.selectionAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'selectionAsync');
+    }
+    await expoHaptics.selectionAsync();
+}
+/**
+ * Uses the device haptics engine directly to provide physical feedback to the user. A no-op on
+ * every platform except Android.
+ * @platform android
+ */
+export async function performAndroidHapticsAsync(type) {
+    if (Platform.OS !== 'android') {
+        return;
+    }
+    if (!expoHaptics.performHapticsAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'performHapticsAsync');
+    }
+    await expoHaptics.performHapticsAsync(type);
+}

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { notificationAsync, impactAsync, selectionAsync, performAndroidHapticsAsync, } from './haptics';
+export { NotificationFeedbackType, ImpactFeedbackStyle, AndroidHaptics } from './types';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { notificationAsync, impactAsync, selectionAsync, performAndroidHapticsAsync, } from './haptics.js';
+export { NotificationFeedbackType, ImpactFeedbackStyle, AndroidHaptics } from './types.js';

package/build/core/native-module.d.ts

@@ -0,0 +1,8 @@
+import type { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+export type INativeHapticsModule = {
+    notificationAsync?(type: NotificationFeedbackType): Promise<void>;
+    impactAsync?(style: ImpactFeedbackStyle): Promise<void>;
+    selectionAsync?(): Promise<void>;
+    performHapticsAsync?(type: AndroidHaptics): Promise<void>;
+};
+export declare const expoHaptics: INativeHapticsModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_HAPTICS_MODULE_NAME = 'ExpoHaptics';
+export const expoHaptics = requireNativeModule(EXPO_HAPTICS_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The type of notification feedback generated by a `UINotificationFeedbackGenerator` object.
+ * [`UINotificationFeedbackType`](https://developer.apple.com/documentation/uikit/uinotificationfeedbackgenerator/feedbacktype).
+ */
+export declare enum NotificationFeedbackType {
+    /** A notification feedback type indicating that a task has completed successfully. */
+    Success = "success",
+    /** A notification feedback type indicating that a task has produced a warning. */
+    Warning = "warning",
+    /** A notification feedback type indicating that a task has failed. */
+    Error = "error"
+}
+/**
+ * The mass of the objects in the collision simulated by a `UIImpactFeedbackGenerator` object.
+ * [`UIImpactFeedbackStyle`](https://developer.apple.com/documentation/uikit/uiimpactfeedbackgenerator/feedbackstyle).
+ */
+export declare enum ImpactFeedbackStyle {
+    /** A collision between small, light user interface elements. */
+    Light = "light",
+    /** A collision between moderately sized user interface elements. */
+    Medium = "medium",
+    /** A collision between large, heavy user interface elements. */
+    Heavy = "heavy",
+    /**
+     * A collision between user interface elements that are soft, exhibiting a large amount of
+     * compression or elasticity.
+     */
+    Soft = "soft",
+    /**
+     * A collision between user interface elements that are rigid, exhibiting a small amount of
+     * compression or elasticity.
+     */
+    Rigid = "rigid"
+}
+/**
+ * Feedback effects driven directly by Android's haptics engine, via `performAndroidHapticsAsync`.
+ * @platform android
+ */
+export declare enum AndroidHaptics {
+    /** A haptic effect to signal the confirmation or successful completion of a user interaction. */
+    Confirm = "confirm",
+    /** A haptic effect to signal the rejection or failure of a user interaction. */
+    Reject = "reject",
+    /** The user has started a gesture (for example, on the soft keyboard). */
+    Gesture_Start = "gesture-start",
+    /** The user has finished a gesture (for example, on the soft keyboard). */
+    Gesture_End = "gesture-end",
+    /** The user has toggled a switch or button into the on position. */
+    Toggle_On = "toggle-on",
+    /** The user has toggled a switch or button into the off position. */
+    Toggle_Off = "toggle-off",
+    /** The user has pressed either an hour or minute tick of a Clock. */
+    Clock_Tick = "clock-tick",
+    /** The user has performed a context click on an object. */
+    Context_Click = "context-click",
+    /** The user has started a drag-and-drop gesture. The drag target has just been "picked up". */
+    Drag_Start = "drag-start",
+    /** The user has pressed a soft keyboard key. */
+    Keyboard_Tap = "keyboard-tap",
+    /** The user has pressed a virtual or software keyboard key. */
+    Keyboard_Press = "keyboard-press",
+    /** The user has released a virtual keyboard key. */
+    Keyboard_Release = "keyboard-release",
+    /** The user has performed a long press on an object that results in an action being performed. */
+    Long_Press = "long-press",
+    /** The user has pressed on a virtual on-screen key. */
+    Virtual_Key = "virtual-key",
+    /** The user has released a virtual key. */
+    Virtual_Key_Release = "virtual-key-release",
+    /** No haptic feedback should be performed. */
+    No_Haptics = "no-haptics",
+    /**
+     * The user is switching between a series of potential choices. For example, items in a list
+     * or discrete points on a slider.
+     */
+    Segment_Tick = "segment-tick",
+    /**
+     * The user is switching between a series of many potential choices. For example, minutes on a
+     * clock face or individual percentages. Expected to be very soft, so as not to be uncomfortable
+     * when performed a lot in quick succession — if the device can't make a suitably soft
+     * vibration, it may not make any vibration at all.
+     */
+    Segment_Frequent_Tick = "segment-frequent-tick",
+    /** The user has performed a selection/insertion handle move on a text field. */
+    Text_Handle_Move = "text-handle-move"
+}

package/build/core/types.js

@@ -0,0 +1,89 @@
+/**
+ * The type of notification feedback generated by a `UINotificationFeedbackGenerator` object.
+ * [`UINotificationFeedbackType`](https://developer.apple.com/documentation/uikit/uinotificationfeedbackgenerator/feedbacktype).
+ */
+export var NotificationFeedbackType;
+(function (NotificationFeedbackType) {
+    /** A notification feedback type indicating that a task has completed successfully. */
+    NotificationFeedbackType["Success"] = "success";
+    /** A notification feedback type indicating that a task has produced a warning. */
+    NotificationFeedbackType["Warning"] = "warning";
+    /** A notification feedback type indicating that a task has failed. */
+    NotificationFeedbackType["Error"] = "error";
+})(NotificationFeedbackType || (NotificationFeedbackType = {}));
+/**
+ * The mass of the objects in the collision simulated by a `UIImpactFeedbackGenerator` object.
+ * [`UIImpactFeedbackStyle`](https://developer.apple.com/documentation/uikit/uiimpactfeedbackgenerator/feedbackstyle).
+ */
+export var ImpactFeedbackStyle;
+(function (ImpactFeedbackStyle) {
+    /** A collision between small, light user interface elements. */
+    ImpactFeedbackStyle["Light"] = "light";
+    /** A collision between moderately sized user interface elements. */
+    ImpactFeedbackStyle["Medium"] = "medium";
+    /** A collision between large, heavy user interface elements. */
+    ImpactFeedbackStyle["Heavy"] = "heavy";
+    /**
+     * A collision between user interface elements that are soft, exhibiting a large amount of
+     * compression or elasticity.
+     */
+    ImpactFeedbackStyle["Soft"] = "soft";
+    /**
+     * A collision between user interface elements that are rigid, exhibiting a small amount of
+     * compression or elasticity.
+     */
+    ImpactFeedbackStyle["Rigid"] = "rigid";
+})(ImpactFeedbackStyle || (ImpactFeedbackStyle = {}));
+/**
+ * Feedback effects driven directly by Android's haptics engine, via `performAndroidHapticsAsync`.
+ * @platform android
+ */
+export var AndroidHaptics;
+(function (AndroidHaptics) {
+    /** A haptic effect to signal the confirmation or successful completion of a user interaction. */
+    AndroidHaptics["Confirm"] = "confirm";
+    /** A haptic effect to signal the rejection or failure of a user interaction. */
+    AndroidHaptics["Reject"] = "reject";
+    /** The user has started a gesture (for example, on the soft keyboard). */
+    AndroidHaptics["Gesture_Start"] = "gesture-start";
+    /** The user has finished a gesture (for example, on the soft keyboard). */
+    AndroidHaptics["Gesture_End"] = "gesture-end";
+    /** The user has toggled a switch or button into the on position. */
+    AndroidHaptics["Toggle_On"] = "toggle-on";
+    /** The user has toggled a switch or button into the off position. */
+    AndroidHaptics["Toggle_Off"] = "toggle-off";
+    /** The user has pressed either an hour or minute tick of a Clock. */
+    AndroidHaptics["Clock_Tick"] = "clock-tick";
+    /** The user has performed a context click on an object. */
+    AndroidHaptics["Context_Click"] = "context-click";
+    /** The user has started a drag-and-drop gesture. The drag target has just been "picked up". */
+    AndroidHaptics["Drag_Start"] = "drag-start";
+    /** The user has pressed a soft keyboard key. */
+    AndroidHaptics["Keyboard_Tap"] = "keyboard-tap";
+    /** The user has pressed a virtual or software keyboard key. */
+    AndroidHaptics["Keyboard_Press"] = "keyboard-press";
+    /** The user has released a virtual keyboard key. */
+    AndroidHaptics["Keyboard_Release"] = "keyboard-release";
+    /** The user has performed a long press on an object that results in an action being performed. */
+    AndroidHaptics["Long_Press"] = "long-press";
+    /** The user has pressed on a virtual on-screen key. */
+    AndroidHaptics["Virtual_Key"] = "virtual-key";
+    /** The user has released a virtual key. */
+    AndroidHaptics["Virtual_Key_Release"] = "virtual-key-release";
+    /** No haptic feedback should be performed. */
+    AndroidHaptics["No_Haptics"] = "no-haptics";
+    /**
+     * The user is switching between a series of potential choices. For example, items in a list
+     * or discrete points on a slider.
+     */
+    AndroidHaptics["Segment_Tick"] = "segment-tick";
+    /**
+     * The user is switching between a series of many potential choices. For example, minutes on a
+     * clock face or individual percentages. Expected to be very soft, so as not to be uncomfortable
+     * when performed a lot in quick succession — if the device can't make a suitably soft
+     * vibration, it may not make any vibration at all.
+     */
+    AndroidHaptics["Segment_Frequent_Tick"] = "segment-frequent-tick";
+    /** The user has performed a selection/insertion handle move on a text field. */
+    AndroidHaptics["Text_Handle_Move"] = "text-handle-move";
+})(AndroidHaptics || (AndroidHaptics = {}));

package/build/react/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/haptics/react: the React entry over the framework-agnostic core.
+// Upstream ships free async functions and three enums, no per-instance state and no event
+// stream (same shape as @symbiote-native/local-auth) — there is nothing for a hook to wrap, so
+// this is a plain re-export.
+export * from '../core/index.js';

package/build/svelte/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/svelte/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/haptics/svelte: the Svelte entry over the framework-agnostic core.
+// Upstream ships free async functions and three enums, no per-instance state and no event
+// stream (same shape as @symbiote-native/local-auth) — there is nothing for a rune to wrap, so
+// this is a plain re-export. Svelte's lifecycle bucket is `runes/` (adapters/svelte/src/runes —
+// never React's `hooks` or Vue's `composables`), and this package has none to fill.
+export * from '../core/index.js';

package/build/vue/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/haptics/vue: the Vue entry over the framework-agnostic core. Same reasoning
+// as the React entry — no per-instance state or event stream to wire onto Vue's reactivity, so
+// this is a plain re-export.
+export * from '../core/index.js';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/haptics/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,0FAA0F;AAC1F,yCAAyC;AACzC,cAAc,SAAS,CAAC"}

package/build-ngc/core/haptics.d.ts

@@ -0,0 +1,24 @@
+import { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+/**
+ * The kind of notification response used in the feedback. On Android it is simulated using
+ * `Vibrator`; on iOS it maps directly to `UINotificationFeedbackType`.
+ */
+export declare function notificationAsync(type?: NotificationFeedbackType): Promise<void>;
+/**
+ * A collision indicator. On Android it is simulated using `Vibrator`; on iOS it maps directly to
+ * `UIImpactFeedbackStyle`.
+ * @see Android's `Vibrator` API is not recommended for haptics feedback — prefer
+ * `performAndroidHapticsAsync`, which drives the device haptics engine directly and does not
+ * require the `VIBRATE` permission.
+ */
+export declare function impactAsync(style?: ImpactFeedbackStyle): Promise<void>;
+/**
+ * Lets the user know a selection change has been registered.
+ */
+export declare function selectionAsync(): Promise<void>;
+/**
+ * Uses the device haptics engine directly to provide physical feedback to the user. A no-op on
+ * every platform except Android.
+ * @platform android
+ */
+export declare function performAndroidHapticsAsync(type: AndroidHaptics): Promise<void>;

package/build-ngc/core/haptics.js

@@ -0,0 +1,51 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+import { expoHaptics } from './native-module';
+import { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+const NATIVE_MODULE_NAME = 'expo-haptics';
+/**
+ * The kind of notification response used in the feedback. On Android it is simulated using
+ * `Vibrator`; on iOS it maps directly to `UINotificationFeedbackType`.
+ */
+export async function notificationAsync(type = NotificationFeedbackType.Success) {
+    if (!expoHaptics.notificationAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'notificationAsync');
+    }
+    await expoHaptics.notificationAsync(type);
+}
+/**
+ * A collision indicator. On Android it is simulated using `Vibrator`; on iOS it maps directly to
+ * `UIImpactFeedbackStyle`.
+ * @see Android's `Vibrator` API is not recommended for haptics feedback — prefer
+ * `performAndroidHapticsAsync`, which drives the device haptics engine directly and does not
+ * require the `VIBRATE` permission.
+ */
+export async function impactAsync(style = ImpactFeedbackStyle.Medium) {
+    if (!expoHaptics.impactAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'impactAsync');
+    }
+    await expoHaptics.impactAsync(style);
+}
+/**
+ * Lets the user know a selection change has been registered.
+ */
+export async function selectionAsync() {
+    if (!expoHaptics.selectionAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'selectionAsync');
+    }
+    await expoHaptics.selectionAsync();
+}
+/**
+ * Uses the device haptics engine directly to provide physical feedback to the user. A no-op on
+ * every platform except Android.
+ * @platform android
+ */
+export async function performAndroidHapticsAsync(type) {
+    if (Platform.OS !== 'android') {
+        return;
+    }
+    if (!expoHaptics.performHapticsAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'performHapticsAsync');
+    }
+    await expoHaptics.performHapticsAsync(type);
+}
+//# sourceMappingURL=haptics.js.map

package/build-ngc/core/haptics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"haptics.js","sourceRoot":"","sources":["../../src/core/haptics.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAElE,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,wBAAwB,EAAE,MAAM,SAAS,CAAC;AAExF,MAAM,kBAAkB,GAAG,cAAc,CAAC;AAE1C;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,OAAiC,wBAAwB,CAAC,OAAO;IAEjE,IAAI,CAAC,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACnC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,mBAAmB,CAAC,CAAC;IACzE,CAAC;IACD,MAAM,WAAW,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,WAAW,CAC/B,QAA6B,mBAAmB,CAAC,MAAM;IAEvD,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;QAC7B,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,aAAa,CAAC,CAAC;IACnE,CAAC;IACD,MAAM,WAAW,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;AACvC,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;QAChC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,WAAW,CAAC,cAAc,EAAE,CAAC;AACrC,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAAC,IAAoB;IACnE,IAAI,QAAQ,CAAC,EAAE,KAAK,SAAS,EAAE,CAAC;QAC9B,OAAO;IACT,CAAC;IACD,IAAI,CAAC,WAAW,CAAC,mBAAmB,EAAE,CAAC;QACrC,MAAM,IAAI,mBAAmB,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,WAAW,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC;AAC9C,CAAC"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,2 @@
+export { notificationAsync, impactAsync, selectionAsync, performAndroidHapticsAsync, } from './haptics';
+export { NotificationFeedbackType, ImpactFeedbackStyle, AndroidHaptics } from './types';

package/build-ngc/core/index.js

@@ -0,0 +1,3 @@
+export { notificationAsync, impactAsync, selectionAsync, performAndroidHapticsAsync, } from './haptics';
+export { NotificationFeedbackType, ImpactFeedbackStyle, AndroidHaptics } from './types';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,iBAAiB,EACjB,WAAW,EACX,cAAc,EACd,0BAA0B,GAC3B,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,8 @@
+import type { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+export type INativeHapticsModule = {
+    notificationAsync?(type: NotificationFeedbackType): Promise<void>;
+    impactAsync?(style: ImpactFeedbackStyle): Promise<void>;
+    selectionAsync?(): Promise<void>;
+    performHapticsAsync?(type: AndroidHaptics): Promise<void>;
+};
+export declare const expoHaptics: INativeHapticsModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_HAPTICS_MODULE_NAME = 'ExpoHaptics';
+export const expoHaptics = requireNativeModule(EXPO_HAPTICS_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,wBAAwB,GAAG,aAAa,CAAC;AAgB/C,MAAM,CAAC,MAAM,WAAW,GAAG,mBAAmB,CAAuB,wBAAwB,CAAC,CAAC"}

package/build-ngc/core/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The type of notification feedback generated by a `UINotificationFeedbackGenerator` object.
+ * [`UINotificationFeedbackType`](https://developer.apple.com/documentation/uikit/uinotificationfeedbackgenerator/feedbacktype).
+ */
+export declare enum NotificationFeedbackType {
+    /** A notification feedback type indicating that a task has completed successfully. */
+    Success = "success",
+    /** A notification feedback type indicating that a task has produced a warning. */
+    Warning = "warning",
+    /** A notification feedback type indicating that a task has failed. */
+    Error = "error"
+}
+/**
+ * The mass of the objects in the collision simulated by a `UIImpactFeedbackGenerator` object.
+ * [`UIImpactFeedbackStyle`](https://developer.apple.com/documentation/uikit/uiimpactfeedbackgenerator/feedbackstyle).
+ */
+export declare enum ImpactFeedbackStyle {
+    /** A collision between small, light user interface elements. */
+    Light = "light",
+    /** A collision between moderately sized user interface elements. */
+    Medium = "medium",
+    /** A collision between large, heavy user interface elements. */
+    Heavy = "heavy",
+    /**
+     * A collision between user interface elements that are soft, exhibiting a large amount of
+     * compression or elasticity.
+     */
+    Soft = "soft",
+    /**
+     * A collision between user interface elements that are rigid, exhibiting a small amount of
+     * compression or elasticity.
+     */
+    Rigid = "rigid"
+}
+/**
+ * Feedback effects driven directly by Android's haptics engine, via `performAndroidHapticsAsync`.
+ * @platform android
+ */
+export declare enum AndroidHaptics {
+    /** A haptic effect to signal the confirmation or successful completion of a user interaction. */
+    Confirm = "confirm",
+    /** A haptic effect to signal the rejection or failure of a user interaction. */
+    Reject = "reject",
+    /** The user has started a gesture (for example, on the soft keyboard). */
+    Gesture_Start = "gesture-start",
+    /** The user has finished a gesture (for example, on the soft keyboard). */
+    Gesture_End = "gesture-end",
+    /** The user has toggled a switch or button into the on position. */
+    Toggle_On = "toggle-on",
+    /** The user has toggled a switch or button into the off position. */
+    Toggle_Off = "toggle-off",
+    /** The user has pressed either an hour or minute tick of a Clock. */
+    Clock_Tick = "clock-tick",
+    /** The user has performed a context click on an object. */
+    Context_Click = "context-click",
+    /** The user has started a drag-and-drop gesture. The drag target has just been "picked up". */
+    Drag_Start = "drag-start",
+    /** The user has pressed a soft keyboard key. */
+    Keyboard_Tap = "keyboard-tap",
+    /** The user has pressed a virtual or software keyboard key. */
+    Keyboard_Press = "keyboard-press",
+    /** The user has released a virtual keyboard key. */
+    Keyboard_Release = "keyboard-release",
+    /** The user has performed a long press on an object that results in an action being performed. */
+    Long_Press = "long-press",
+    /** The user has pressed on a virtual on-screen key. */
+    Virtual_Key = "virtual-key",
+    /** The user has released a virtual key. */
+    Virtual_Key_Release = "virtual-key-release",
+    /** No haptic feedback should be performed. */
+    No_Haptics = "no-haptics",
+    /**
+     * The user is switching between a series of potential choices. For example, items in a list
+     * or discrete points on a slider.
+     */
+    Segment_Tick = "segment-tick",
+    /**
+     * The user is switching between a series of many potential choices. For example, minutes on a
+     * clock face or individual percentages. Expected to be very soft, so as not to be uncomfortable
+     * when performed a lot in quick succession — if the device can't make a suitably soft
+     * vibration, it may not make any vibration at all.
+     */
+    Segment_Frequent_Tick = "segment-frequent-tick",
+    /** The user has performed a selection/insertion handle move on a text field. */
+    Text_Handle_Move = "text-handle-move"
+}

package/build-ngc/core/types.js

@@ -0,0 +1,90 @@
+/**
+ * The type of notification feedback generated by a `UINotificationFeedbackGenerator` object.
+ * [`UINotificationFeedbackType`](https://developer.apple.com/documentation/uikit/uinotificationfeedbackgenerator/feedbacktype).
+ */
+export var NotificationFeedbackType;
+(function (NotificationFeedbackType) {
+    /** A notification feedback type indicating that a task has completed successfully. */
+    NotificationFeedbackType["Success"] = "success";
+    /** A notification feedback type indicating that a task has produced a warning. */
+    NotificationFeedbackType["Warning"] = "warning";
+    /** A notification feedback type indicating that a task has failed. */
+    NotificationFeedbackType["Error"] = "error";
+})(NotificationFeedbackType || (NotificationFeedbackType = {}));
+/**
+ * The mass of the objects in the collision simulated by a `UIImpactFeedbackGenerator` object.
+ * [`UIImpactFeedbackStyle`](https://developer.apple.com/documentation/uikit/uiimpactfeedbackgenerator/feedbackstyle).
+ */
+export var ImpactFeedbackStyle;
+(function (ImpactFeedbackStyle) {
+    /** A collision between small, light user interface elements. */
+    ImpactFeedbackStyle["Light"] = "light";
+    /** A collision between moderately sized user interface elements. */
+    ImpactFeedbackStyle["Medium"] = "medium";
+    /** A collision between large, heavy user interface elements. */
+    ImpactFeedbackStyle["Heavy"] = "heavy";
+    /**
+     * A collision between user interface elements that are soft, exhibiting a large amount of
+     * compression or elasticity.
+     */
+    ImpactFeedbackStyle["Soft"] = "soft";
+    /**
+     * A collision between user interface elements that are rigid, exhibiting a small amount of
+     * compression or elasticity.
+     */
+    ImpactFeedbackStyle["Rigid"] = "rigid";
+})(ImpactFeedbackStyle || (ImpactFeedbackStyle = {}));
+/**
+ * Feedback effects driven directly by Android's haptics engine, via `performAndroidHapticsAsync`.
+ * @platform android
+ */
+export var AndroidHaptics;
+(function (AndroidHaptics) {
+    /** A haptic effect to signal the confirmation or successful completion of a user interaction. */
+    AndroidHaptics["Confirm"] = "confirm";
+    /** A haptic effect to signal the rejection or failure of a user interaction. */
+    AndroidHaptics["Reject"] = "reject";
+    /** The user has started a gesture (for example, on the soft keyboard). */
+    AndroidHaptics["Gesture_Start"] = "gesture-start";
+    /** The user has finished a gesture (for example, on the soft keyboard). */
+    AndroidHaptics["Gesture_End"] = "gesture-end";
+    /** The user has toggled a switch or button into the on position. */
+    AndroidHaptics["Toggle_On"] = "toggle-on";
+    /** The user has toggled a switch or button into the off position. */
+    AndroidHaptics["Toggle_Off"] = "toggle-off";
+    /** The user has pressed either an hour or minute tick of a Clock. */
+    AndroidHaptics["Clock_Tick"] = "clock-tick";
+    /** The user has performed a context click on an object. */
+    AndroidHaptics["Context_Click"] = "context-click";
+    /** The user has started a drag-and-drop gesture. The drag target has just been "picked up". */
+    AndroidHaptics["Drag_Start"] = "drag-start";
+    /** The user has pressed a soft keyboard key. */
+    AndroidHaptics["Keyboard_Tap"] = "keyboard-tap";
+    /** The user has pressed a virtual or software keyboard key. */
+    AndroidHaptics["Keyboard_Press"] = "keyboard-press";
+    /** The user has released a virtual keyboard key. */
+    AndroidHaptics["Keyboard_Release"] = "keyboard-release";
+    /** The user has performed a long press on an object that results in an action being performed. */
+    AndroidHaptics["Long_Press"] = "long-press";
+    /** The user has pressed on a virtual on-screen key. */
+    AndroidHaptics["Virtual_Key"] = "virtual-key";
+    /** The user has released a virtual key. */
+    AndroidHaptics["Virtual_Key_Release"] = "virtual-key-release";
+    /** No haptic feedback should be performed. */
+    AndroidHaptics["No_Haptics"] = "no-haptics";
+    /**
+     * The user is switching between a series of potential choices. For example, items in a list
+     * or discrete points on a slider.
+     */
+    AndroidHaptics["Segment_Tick"] = "segment-tick";
+    /**
+     * The user is switching between a series of many potential choices. For example, minutes on a
+     * clock face or individual percentages. Expected to be very soft, so as not to be uncomfortable
+     * when performed a lot in quick succession — if the device can't make a suitably soft
+     * vibration, it may not make any vibration at all.
+     */
+    AndroidHaptics["Segment_Frequent_Tick"] = "segment-frequent-tick";
+    /** The user has performed a selection/insertion handle move on a text field. */
+    AndroidHaptics["Text_Handle_Move"] = "text-handle-move";
+})(AndroidHaptics || (AndroidHaptics = {}));
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,CAAN,IAAY,wBAOX;AAPD,WAAY,wBAAwB;IAClC,sFAAsF;IACtF,+CAAmB,CAAA;IACnB,kFAAkF;IAClF,+CAAmB,CAAA;IACnB,sEAAsE;IACtE,2CAAe,CAAA;AACjB,CAAC,EAPW,wBAAwB,KAAxB,wBAAwB,QAOnC;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,mBAiBX;AAjBD,WAAY,mBAAmB;IAC7B,gEAAgE;IAChE,sCAAe,CAAA;IACf,oEAAoE;IACpE,wCAAiB,CAAA;IACjB,gEAAgE;IAChE,sCAAe,CAAA;IACf;;;OAGG;IACH,oCAAa,CAAA;IACb;;;OAGG;IACH,sCAAe,CAAA;AACjB,CAAC,EAjBW,mBAAmB,KAAnB,mBAAmB,QAiB9B;AAED;;;GAGG;AACH,MAAM,CAAN,IAAY,cA+CX;AA/CD,WAAY,cAAc;IACxB,iGAAiG;IACjG,qCAAmB,CAAA;IACnB,gFAAgF;IAChF,mCAAiB,CAAA;IACjB,0EAA0E;IAC1E,iDAA+B,CAAA;IAC/B,2EAA2E;IAC3E,6CAA2B,CAAA;IAC3B,oEAAoE;IACpE,yCAAuB,CAAA;IACvB,qEAAqE;IACrE,2CAAyB,CAAA;IACzB,qEAAqE;IACrE,2CAAyB,CAAA;IACzB,2DAA2D;IAC3D,iDAA+B,CAAA;IAC/B,+FAA+F;IAC/F,2CAAyB,CAAA;IACzB,gDAAgD;IAChD,+CAA6B,CAAA;IAC7B,+DAA+D;IAC/D,mDAAiC,CAAA;IACjC,oDAAoD;IACpD,uDAAqC,CAAA;IACrC,kGAAkG;IAClG,2CAAyB,CAAA;IACzB,uDAAuD;IACvD,6CAA2B,CAAA;IAC3B,2CAA2C;IAC3C,6DAA2C,CAAA;IAC3C,8CAA8C;IAC9C,2CAAyB,CAAA;IACzB;;;OAGG;IACH,+CAA6B,CAAA;IAC7B;;;;;OAKG;IACH,iEAA+C,CAAA;IAC/C,gFAAgF;IAChF,uDAAqC,CAAA;AACvC,CAAC,EA/CW,cAAc,KAAd,cAAc,QA+CzB"}

package/native-link.json

@@ -0,0 +1,12 @@
+{
+  "android": {
+    "gradleProjectName": "expo-haptics",
+    "modules": [
+      {
+        "importPath": "expo.modules.haptics.HapticsModule",
+        "className": "HapticsModule",
+        "nativeName": "ExpoHaptics"
+      }
+    ]
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/haptics",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "expo-haptics wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, and Angular adapters. Impact/notification/selection vibration feedback via iOS's Taptic Engine and Android's Vibrator API.",
   "license": "MIT",
   "repository": {
@@ -13,7 +13,112 @@
     "url": "https://github.com/OneEyed1366/symbiote-native/issues"
   },
   "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
+    },
+    "./react": {
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
+    },
+    "./svelte": {
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
+  ],
   "publishConfig": {
     "access": "public"
+  },
+  "dependencies": {
+    "expo-haptics": "57.0.1",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@symbiote-native/angular": ">=0.6.2",
+    "@symbiote-native/engine": ">=0.1.7",
+    "@symbiote-native/react": ">=0.2.8",
+    "@symbiote-native/svelte": ">=0.1.0",
+    "@symbiote-native/vue": ">=0.3.8",
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "svelte": "^5.56.0",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "0.7.0",
+    "@symbiote-native/engine": "0.2.0",
+    "@symbiote-native/react": "0.3.0",
+    "@symbiote-native/svelte": "0.2.0",
+    "@symbiote-native/test-utils": "0.1.6",
+    "@symbiote-native/vue": "0.4.0"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
   }
 }

package/src/angular/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/haptics/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — no per-instance state or event stream to wrap in a
+// service, so this is a plain re-export.
+export * from '../core';

package/src/core/haptics.ts

@@ -0,0 +1,60 @@
+import { Platform, UnavailabilityError } from 'expo-modules-core';
+
+import { expoHaptics } from './native-module';
+import { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+
+const NATIVE_MODULE_NAME = 'expo-haptics';
+
+/**
+ * The kind of notification response used in the feedback. On Android it is simulated using
+ * `Vibrator`; on iOS it maps directly to `UINotificationFeedbackType`.
+ */
+export async function notificationAsync(
+  type: NotificationFeedbackType = NotificationFeedbackType.Success,
+): Promise<void> {
+  if (!expoHaptics.notificationAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'notificationAsync');
+  }
+  await expoHaptics.notificationAsync(type);
+}
+
+/**
+ * A collision indicator. On Android it is simulated using `Vibrator`; on iOS it maps directly to
+ * `UIImpactFeedbackStyle`.
+ * @see Android's `Vibrator` API is not recommended for haptics feedback — prefer
+ * `performAndroidHapticsAsync`, which drives the device haptics engine directly and does not
+ * require the `VIBRATE` permission.
+ */
+export async function impactAsync(
+  style: ImpactFeedbackStyle = ImpactFeedbackStyle.Medium,
+): Promise<void> {
+  if (!expoHaptics.impactAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'impactAsync');
+  }
+  await expoHaptics.impactAsync(style);
+}
+
+/**
+ * Lets the user know a selection change has been registered.
+ */
+export async function selectionAsync(): Promise<void> {
+  if (!expoHaptics.selectionAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'selectionAsync');
+  }
+  await expoHaptics.selectionAsync();
+}
+
+/**
+ * Uses the device haptics engine directly to provide physical feedback to the user. A no-op on
+ * every platform except Android.
+ * @platform android
+ */
+export async function performAndroidHapticsAsync(type: AndroidHaptics): Promise<void> {
+  if (Platform.OS !== 'android') {
+    return;
+  }
+  if (!expoHaptics.performHapticsAsync) {
+    throw new UnavailabilityError(NATIVE_MODULE_NAME, 'performHapticsAsync');
+  }
+  await expoHaptics.performHapticsAsync(type);
+}

package/src/core/index.ts

@@ -0,0 +1,7 @@
+export {
+  notificationAsync,
+  impactAsync,
+  selectionAsync,
+  performAndroidHapticsAsync,
+} from './haptics';
+export { NotificationFeedbackType, ImpactFeedbackStyle, AndroidHaptics } from './types';

package/src/core/native-module.ts

@@ -0,0 +1,20 @@
+import { requireNativeModule } from 'expo-modules-core';
+import type { AndroidHaptics, ImpactFeedbackStyle, NotificationFeedbackType } from './types';
+
+const EXPO_HAPTICS_MODULE_NAME = 'ExpoHaptics';
+
+// Every method is optional — each call site checks for its presence before calling through and
+// throws an UnavailabilityError itself, matching upstream's own per-platform capability checks
+// rather than assuming the native module implements the whole surface (same convention as
+// packages/local-auth/src/core/native-module.ts). `performHapticsAsync` in particular only
+// exists on the Android native module (HapticsModule.kt) — iOS's HapticsModule.swift has no
+// equivalent, since `performAndroidHapticsAsync` short-circuits on non-Android platforms before
+// ever reaching this call.
+export type INativeHapticsModule = {
+  notificationAsync?(type: NotificationFeedbackType): Promise<void>;
+  impactAsync?(style: ImpactFeedbackStyle): Promise<void>;
+  selectionAsync?(): Promise<void>;
+  performHapticsAsync?(type: AndroidHaptics): Promise<void>;
+};
+
+export const expoHaptics = requireNativeModule<INativeHapticsModule>(EXPO_HAPTICS_MODULE_NAME);

package/src/core/types.ts

@@ -0,0 +1,88 @@
+/**
+ * The type of notification feedback generated by a `UINotificationFeedbackGenerator` object.
+ * [`UINotificationFeedbackType`](https://developer.apple.com/documentation/uikit/uinotificationfeedbackgenerator/feedbacktype).
+ */
+export enum NotificationFeedbackType {
+  /** A notification feedback type indicating that a task has completed successfully. */
+  Success = 'success',
+  /** A notification feedback type indicating that a task has produced a warning. */
+  Warning = 'warning',
+  /** A notification feedback type indicating that a task has failed. */
+  Error = 'error',
+}
+
+/**
+ * The mass of the objects in the collision simulated by a `UIImpactFeedbackGenerator` object.
+ * [`UIImpactFeedbackStyle`](https://developer.apple.com/documentation/uikit/uiimpactfeedbackgenerator/feedbackstyle).
+ */
+export enum ImpactFeedbackStyle {
+  /** A collision between small, light user interface elements. */
+  Light = 'light',
+  /** A collision between moderately sized user interface elements. */
+  Medium = 'medium',
+  /** A collision between large, heavy user interface elements. */
+  Heavy = 'heavy',
+  /**
+   * A collision between user interface elements that are soft, exhibiting a large amount of
+   * compression or elasticity.
+   */
+  Soft = 'soft',
+  /**
+   * A collision between user interface elements that are rigid, exhibiting a small amount of
+   * compression or elasticity.
+   */
+  Rigid = 'rigid',
+}
+
+/**
+ * Feedback effects driven directly by Android's haptics engine, via `performAndroidHapticsAsync`.
+ * @platform android
+ */
+export enum AndroidHaptics {
+  /** A haptic effect to signal the confirmation or successful completion of a user interaction. */
+  Confirm = 'confirm',
+  /** A haptic effect to signal the rejection or failure of a user interaction. */
+  Reject = 'reject',
+  /** The user has started a gesture (for example, on the soft keyboard). */
+  Gesture_Start = 'gesture-start',
+  /** The user has finished a gesture (for example, on the soft keyboard). */
+  Gesture_End = 'gesture-end',
+  /** The user has toggled a switch or button into the on position. */
+  Toggle_On = 'toggle-on',
+  /** The user has toggled a switch or button into the off position. */
+  Toggle_Off = 'toggle-off',
+  /** The user has pressed either an hour or minute tick of a Clock. */
+  Clock_Tick = 'clock-tick',
+  /** The user has performed a context click on an object. */
+  Context_Click = 'context-click',
+  /** The user has started a drag-and-drop gesture. The drag target has just been "picked up". */
+  Drag_Start = 'drag-start',
+  /** The user has pressed a soft keyboard key. */
+  Keyboard_Tap = 'keyboard-tap',
+  /** The user has pressed a virtual or software keyboard key. */
+  Keyboard_Press = 'keyboard-press',
+  /** The user has released a virtual keyboard key. */
+  Keyboard_Release = 'keyboard-release',
+  /** The user has performed a long press on an object that results in an action being performed. */
+  Long_Press = 'long-press',
+  /** The user has pressed on a virtual on-screen key. */
+  Virtual_Key = 'virtual-key',
+  /** The user has released a virtual key. */
+  Virtual_Key_Release = 'virtual-key-release',
+  /** No haptic feedback should be performed. */
+  No_Haptics = 'no-haptics',
+  /**
+   * The user is switching between a series of potential choices. For example, items in a list
+   * or discrete points on a slider.
+   */
+  Segment_Tick = 'segment-tick',
+  /**
+   * The user is switching between a series of many potential choices. For example, minutes on a
+   * clock face or individual percentages. Expected to be very soft, so as not to be uncomfortable
+   * when performed a lot in quick succession — if the device can't make a suitably soft
+   * vibration, it may not make any vibration at all.
+   */
+  Segment_Frequent_Tick = 'segment-frequent-tick',
+  /** The user has performed a selection/insertion handle move on a text field. */
+  Text_Handle_Move = 'text-handle-move',
+}

package/src/react/index.ts

@@ -0,0 +1,5 @@
+// @symbiote-native/haptics/react: the React entry over the framework-agnostic core.
+// Upstream ships free async functions and three enums, no per-instance state and no event
+// stream (same shape as @symbiote-native/local-auth) — there is nothing for a hook to wrap, so
+// this is a plain re-export.
+export * from '../core';

package/src/svelte/index.ts

@@ -0,0 +1,6 @@
+// @symbiote-native/haptics/svelte: the Svelte entry over the framework-agnostic core.
+// Upstream ships free async functions and three enums, no per-instance state and no event
+// stream (same shape as @symbiote-native/local-auth) — there is nothing for a rune to wrap, so
+// this is a plain re-export. Svelte's lifecycle bucket is `runes/` (adapters/svelte/src/runes —
+// never React's `hooks` or Vue's `composables`), and this package has none to fill.
+export * from '../core';

package/src/vue/index.ts

@@ -0,0 +1,4 @@
+// @symbiote-native/haptics/vue: the Vue entry over the framework-agnostic core. Same reasoning
+// as the React entry — no per-instance state or event stream to wire onto Vue's reactivity, so
+// this is a plain re-export.
+export * from '../core';