@renegades/react-native-tickle 0.1.0 → 0.1.2

package/README.md

@@ -1,4 +1,6 @@
-# react-native-tickle
+<img width="1536" height="1024" alt="banner" src="https://github.com/user-attachments/assets/61f1f3bf-24dc-4e0d-ba6a-4dce3a548c96" />
+
+# @renegades/react-native-tickle
 
 AHAP-style haptics (transient + continuous) on top of [Nitro Modules](https://nitro.margelo.com/) — the core functions are **UI-thread friendly** (`'worklet'`).
 
@@ -6,17 +8,17 @@ AHAP-style haptics (transient + continuous) on top of [Nitro Modules](https://ni
 
 Complete flexibility over iOS haptics with synchronous UI-thread execution.
 
-> iOS only (Core Haptics). Android support could be added in the future, but it’s currently unplanned.
+> iOS only (Core Haptics). Android support could be added in the future, but it's currently unplanned.
 
 ## Installation
 
 ```sh
-npm i react-native-tickle react-native-nitro-modules
+npm i @renegades/react-native-tickle react-native-nitro-modules
 ```
 
 ## Concepts (what to use when)
 
-- **Transient**: Instant “click/tap” events. No duration — you trigger them at a point in time.
+- **Transient**: Instant "click/tap" events. No duration — you trigger them at a point in time.
 - **Continuous (pattern)**: Time-based patterns you _can_ define ahead of time. You provide **events** (with `duration`) and optionally **curves** (automation over time).
 - **Continuous player (real-time)**: For _unpredictable_ input (gesture position, scroll velocity, real-time data). You create a player once, then **start → update (many times) → stop**.
 
@@ -24,10 +26,29 @@ npm i react-native-tickle react-native-nitro-modules
 
 On iOS Core Haptics, a pattern is made of two different building blocks:
 
-- **Events**: things that happen (transient “ticks” or continuous segments) at a `relativeTime`, with base `intensity`/`sharpness`.
-- **Curves**: how parameters (intensity/sharpness) evolve over time via control points, independent of “what event” is currently playing.
+- **Events**: things that happen (transient "ticks" or continuous segments) at a `relativeTime`, with base `intensity`/`sharpness`.
+- **Curves**: how parameters (intensity/sharpness) evolve over time via control points, independent of "what event" is currently playing.
+
+They're separate because they're different object types in Core Haptics (events vs parameter curves) and they serve different jobs: **events define the structure**, **curves define the modulation**. You often combine both in one pattern.
+
+## Haptix Studio
+
+<table>
+<tr>
+<td>
+<img src="https://github.com/user-attachments/assets/9a0edcfa-37ee-440d-9ae3-48fdcce59780" alt="Haptix Studio" width="280" />
+</td>
+<td>
 
-They’re separate because they’re different object types in Core Haptics (events vs parameter curves) and they serve different jobs: **events define the structure**, **curves define the modulation**. You often combine both in one pattern.
+Try out **Haptix Studio** to see what's possible with haptics.
+
+Play with continuous patterns and real-time updates, then export your creations directly into code.
+
+[Download on Test Flight](https://testflight.apple.com/join/HJn3mbb3)
+
+</td>
+</tr>
+</table>
 
 ## Usage
 
@@ -36,7 +57,7 @@ They’re separate because they’re different object types in Core Haptics (eve
 Wrap your app inside `HapticProvider`. This initializes the engine and automatically destroys it when the app goes to background.
 
 ```tsx
-import { HapticProvider } from 'react-native-tickle';
+import { HapticProvider } from '@renegades/react-native-tickle';
 
 export function App() {
   return <HapticProvider>{/* {Rest of your app} */}</HapticProvider>;
@@ -48,7 +69,7 @@ export function App() {
 Play a transient:
 
 ```ts
-import { startHaptic } from 'react-native-tickle';
+import { startHaptic } from '@renegades/react-native-tickle';
 
 startHaptic(
   [
@@ -68,7 +89,7 @@ startHaptic(
 Play a continuous pattern (events + curves together):
 
 ```ts
-import { startHaptic } from 'react-native-tickle';
+import { startHaptic } from '@renegades/react-native-tickle';
 
 startHaptic(
   [
@@ -99,7 +120,7 @@ startHaptic(
 Combine transient + continuous in one pattern:
 
 ```ts
-import { startHaptic } from 'react-native-tickle';
+import { startHaptic } from '@renegades/react-native-tickle';
 
 startHaptic(
   [
@@ -129,10 +150,8 @@ startHaptic(
 
 Use this when you _can't_ predefine a pattern. You start the player, update it in real time, then stop it.
 
-**Using the hook (recommended):**
-
 ```tsx
-import { useContinuousPlayer } from 'react-native-tickle';
+import { useContinuousPlayer } from '@renegades/react-native-tickle';
 
 function MyComponent() {
   const { start, stop, update } = useContinuousPlayer('my-player', 1.0, 0.5);
@@ -150,44 +169,12 @@ function MyComponent() {
 }
 ```
 
-**Manual control:**
-
-```ts
-import {
-  createContinuousPlayer,
-  startContinuousPlayer,
-  updateContinuousPlayer,
-  stopContinuousPlayer,
-  destroyContinuousPlayer,
-} from 'react-native-tickle';
-
-const PLAYER_ID = 'my-player';
-
-createContinuousPlayer(PLAYER_ID, 1.0, 0.5);
-startContinuousPlayer(PLAYER_ID);
-updateContinuousPlayer(PLAYER_ID, 0.8, 0.1);
-stopContinuousPlayer(PLAYER_ID);
-destroyContinuousPlayer(PLAYER_ID);
-```
-
-### Opt out of the provider (manual engine control)
-
-If you don’t want the provider behavior:
-
-```ts
-import { initializeEngine, destroyEngine } from 'react-native-tickle';
-
-initializeEngine();
-// ...
-destroyEngine();
-```
-
-### Stop everything (recommended in screen cleanups)
+### Stop everything
 
-Call `stopAllHaptics()` in your cleanup functions to terminate any ongoing continuous haptics. This prevents haptics from bleeding through to the next screen when navigating.
+If users can navigate away from a screen while haptics are still playing, call `stopAllHaptics()` in your cleanup to stop them.
 
 ```ts
-import { stopAllHaptics } from 'react-native-tickle';
+import { stopAllHaptics } from '@renegades/react-native-tickle';
 import { useEffect } from 'react';
 
 export function SomeScreen() {
@@ -200,10 +187,8 @@ export function SomeScreen() {
 
 Disable haptics globally for users who prefer no haptic feedback. The setting is **persisted** across app restarts. When disabled, all haptic calls become no-ops.
 
-**Using the hook (recommended):**
-
 ```tsx
-import { useHapticsEnabled } from 'react-native-tickle';
+import { useHapticsEnabled } from '@renegades/react-native-tickle';
 
 function SettingsScreen() {
   const [hapticsEnabled, setHapticsEnabled] = useHapticsEnabled();
@@ -212,26 +197,16 @@ function SettingsScreen() {
 }
 ```
 
-**Manual control:**
-
-```ts
-import { setHapticsEnabled, getHapticsEnabled } from 'react-native-tickle';
-
-const isEnabled = getHapticsEnabled(); // true by default
-setHapticsEnabled(false); // Disable all haptics
-setHapticsEnabled(true); // Re-enable haptics
-```
-
 ### System haptics (predefined OS-level feedback)
 
-While the main purpose of this package is to support AHAP-style patterns (transient + continuous haptics with curves), system haptics are also available for completeness. These are simple, predefined OS-level feedback types that don't require pattern definitions. They can be called from the UI thread and don't require the haptic engine to be initialized.
+While the main purpose of this package is to support AHAP-style patterns (transient + continuous haptics with curves), system haptics are also available for completeness. These are simple, predefined OS-level feedback types that don't require pattern definitions. These methods are also UI-thread friendly.
 
 ```ts
 import {
   triggerImpact,
   triggerNotification,
   triggerSelection,
-} from 'react-native-tickle';
+} from '@renegades/react-native-tickle';
 
 // Impact feedback - simulates a physical collision
 triggerImpact('light'); // 'light' | 'medium' | 'heavy' | 'soft' | 'rigid'
@@ -243,6 +218,14 @@ triggerNotification('success'); // 'success' | 'warning' | 'error'
 triggerSelection();
 ```
 
+### Advanced control
+
+For fine-grained control over the haptic API, you can opt out of the managed hooks and call the underlying functions directly:
+
+- **Engine lifecycle**: `initializeEngine()` / `destroyEngine()` instead of `HapticProvider`
+- **Enable/disable toggle**: `setHapticsEnabled()` / `getHapticsEnabled()` instead of `useHapticsEnabled()`
+- **Continuous player**: `createContinuousPlayer()` / `startContinuousPlayer()` / `updateContinuousPlayer()` / `stopContinuousPlayer()` / `destroyContinuousPlayer()` instead of `useContinuousPlayer()`
+
 ## API
 
 | Function                                                               | Purpose                                                         |
@@ -341,6 +324,10 @@ Each call creates an isolated pattern/player — curves from one won't affect ev
 
 > **Note:** The library automatically resets control values to `1.0` at the end of each continuous event, so transients **after** a continuous event finishes are not affected. This limitation only applies to transients **during** a continuous event with active curves.
 
+## Acknowledgment
+
+Shoutout to [Jai](https://github.com/jaic231) for kicking off the Swift implementation 🙌
+
 ## Contributing
 
 - [Development workflow](CONTRIBUTING.md#development-workflow)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renegades/react-native-tickle",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Build and fine-tune haptic patterns with real-time previews",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",
@@ -34,9 +34,8 @@
     "!**/.*"
   ],
   "scripts": {
-    "postinstall": "bash scripts/postinstall.sh",
     "clean": "del-cli android/build example/android/build example/android/app/build example/ios/build lib",
-    "prepare": "bob build",
+    "prepare": "bun --yes nitrogen && bob build",
     "nitrogen": "nitrogen",
     "typecheck": "tsc",
     "lint": "eslint \"**/*.{js,ts,tsx}\"",
@@ -99,7 +98,7 @@
   "peerDependencies": {
     "react": "*",
     "react-native": "*",
-    "react-native-nitro-modules": "^0.32.0"
+    "react-native-nitro-modules": "*"
   },
   "packageManager": "bun@1.1.38",
   "react-native-builder-bob": {