@renegades/react-native-tickle 0.1.0

package/lib/module/index.js

@@ -0,0 +1,254 @@
+"use strict";
+
+import { useEffect, useState, useCallback } from 'react';
+import { AppState } from 'react-native';
+import { NitroModules } from 'react-native-nitro-modules';
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+const TickleHybridObject = NitroModules.createHybridObject('Tickle');
+const boxedTickle = NitroModules.box(TickleHybridObject);
+export function startHaptic(events, curves) {
+  'worklet';
+
+  return boxedTickle.unbox().startHaptic(events, curves);
+}
+export function stopAllHaptics() {
+  'worklet';
+
+  return boxedTickle.unbox().stopAllHaptics();
+}
+export function initializeEngine() {
+  'worklet';
+
+  return boxedTickle.unbox().initializeEngine();
+}
+export function destroyEngine() {
+  'worklet';
+
+  return boxedTickle.unbox().destroyEngine();
+}
+export function createContinuousPlayer(playerId, initialIntensity, initialSharpness) {
+  'worklet';
+
+  return boxedTickle.unbox().createContinuousPlayer(playerId, initialIntensity, initialSharpness);
+}
+export function startContinuousPlayer(playerId) {
+  'worklet';
+
+  return boxedTickle.unbox().startContinuousPlayer(playerId);
+}
+export function updateContinuousPlayer(playerId, intensityControl, sharpnessControl) {
+  'worklet';
+
+  return boxedTickle.unbox().updateContinuousPlayer(playerId, intensityControl, sharpnessControl);
+}
+export function stopContinuousPlayer(playerId) {
+  'worklet';
+
+  return boxedTickle.unbox().stopContinuousPlayer(playerId);
+}
+export function destroyContinuousPlayer(playerId) {
+  'worklet';
+
+  return boxedTickle.unbox().destroyContinuousPlayer(playerId);
+}
+
+// MARK: - System Haptics (Predefined OS-level feedback)
+
+/**
+ * Triggers an impact haptic with the specified style.
+ * Simulates a physical collision feedback.
+ *
+ * @param style - The intensity style of the impact ('rigid' | 'heavy' | 'medium' | 'light' | 'soft')
+ *
+ * @example
+ * ```ts
+ * // Light tap for subtle UI feedback
+ * triggerImpact('light');
+ *
+ * // Heavy impact for significant actions
+ * triggerImpact('heavy');
+ * ```
+ */
+export function triggerImpact(style) {
+  'worklet';
+
+  return boxedTickle.unbox().triggerImpact(style);
+}
+
+/**
+ * Triggers a notification-style haptic for alerts and status updates.
+ * Use this for communicating outcomes of actions to the user.
+ *
+ * @param type - The notification type ('error' | 'success' | 'warning')
+ *
+ * @example
+ * ```ts
+ * // Success feedback after completing an action
+ * triggerNotification('success');
+ *
+ * // Error feedback when something goes wrong
+ * triggerNotification('error');
+ * ```
+ */
+export function triggerNotification(type) {
+  'worklet';
+
+  return boxedTickle.unbox().triggerNotification(type);
+}
+
+/**
+ * Triggers a selection change haptic.
+ * Best used for picker wheels, toggles, and selection changes.
+ *
+ * @example
+ * ```ts
+ * // When user scrolls through picker options
+ * triggerSelection();
+ * ```
+ */
+export function triggerSelection() {
+  'worklet';
+
+  return boxedTickle.unbox().triggerSelection();
+}
+
+// MARK: - Global Haptics Enable/Disable
+
+/**
+ * Enable or disable haptics globally. This setting is persisted across app restarts.
+ * When disabled, all haptic functions become no-ops (no haptics will play).
+ * This does not affect engine initialization/destruction.
+ *
+ * @param enabled - Whether haptics should be enabled
+ */
+export function setHapticsEnabled(enabled) {
+  'worklet';
+
+  return boxedTickle.unbox().setHapticsEnabled(enabled);
+}
+
+/**
+ * Get the current global haptics enabled state.
+ * Defaults to true if not previously set.
+ *
+ * @returns Whether haptics are currently enabled
+ */
+export function getHapticsEnabled() {
+  'worklet';
+
+  return boxedTickle.unbox().getHapticsEnabled();
+}
+
+/**
+ * Hook to manage the global haptics enabled state.
+ * Provides reactive state and a setter function.
+ *
+ * @returns [isEnabled, setEnabled] - Current state and setter function
+ *
+ * @example
+ * ```tsx
+ * function SettingsScreen() {
+ *   const [hapticsEnabled, setHapticsEnabled] = useHapticsEnabled();
+ *
+ *   return (
+ *     <Switch
+ *       value={hapticsEnabled}
+ *       onValueChange={setHapticsEnabled}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export function useHapticsEnabled() {
+  const [enabled, setEnabled] = useState(() => getHapticsEnabled());
+  const setHapticsEnabledState = useCallback(value => {
+    setHapticsEnabled(value);
+    setEnabled(value);
+  }, []);
+  return [enabled, setHapticsEnabledState];
+}
+
+/**
+ * Hook to manage a continuous haptic player lifecycle.
+ *
+ * @param playerId - A unique string key to identify this player (e.g., 'my-palette')
+ * @param initialIntensity - Initial intensity value (0.0 to 1.0)
+ * @param initialSharpness - Initial sharpness value (0.0 to 1.0)
+ *
+ * @returns Object with JS-bound methods for convenience:
+ * - `start()` - Start the continuous haptic
+ * - `stop()` - Stop the continuous haptic
+ * - `update(intensity, sharpness)` - Update haptic parameters
+ * - `playerId` - The player key (for use in worklets)
+ *
+ * @example
+ * ```tsx
+ * const PLAYER_KEY = 'my-palette';
+ *
+ * function MyComponent() {
+ *   const { start, stop, update } = useContinuousPlayer(PLAYER_KEY, 1.0, 0.5);
+ *
+ *   const gesture = Gesture.Pan()
+ *     .onBegin(() => {
+ *       start();
+ *     })
+ *     .onUpdate(() => {
+ *       update(0.5, 0.5);
+ *     })
+ *     .onEnd(() => {
+ *       stop();
+ *     });
+ * }
+ * ```
+ */
+export function useContinuousPlayer(playerId, initialIntensity = 1.0, initialSharpness = 0.5) {
+  useEffect(() => {
+    createContinuousPlayer(playerId, initialIntensity, initialSharpness);
+    return () => {
+      destroyContinuousPlayer(playerId);
+    };
+  }, [playerId, initialIntensity, initialSharpness]);
+  return {
+    start: () => {
+      'worklet';
+
+      startContinuousPlayer(playerId);
+    },
+    stop: () => {
+      'worklet';
+
+      stopContinuousPlayer(playerId);
+    },
+    update: (intensity, sharpness) => {
+      'worklet';
+
+      return updateContinuousPlayer(playerId, intensity, sharpness);
+    },
+    playerId
+  };
+}
+export function useHapticEngine() {
+  useEffect(() => {
+    initializeEngine();
+    const off = AppState.addEventListener('change', state => {
+      if (state === 'active') {
+        initializeEngine();
+      } else if (state === 'background') {
+        destroyEngine();
+      }
+    });
+    return () => {
+      off.remove();
+    };
+  }, []);
+}
+export function HapticProvider({
+  children
+}) {
+  useHapticEngine();
+  return /*#__PURE__*/_jsx(_Fragment, {
+    children: children
+  });
+}
+export { TickleHybridObject };
+//# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["useEffect","useState","useCallback","AppState","NitroModules","Fragment","_Fragment","jsx","_jsx","TickleHybridObject","createHybridObject","boxedTickle","box","startHaptic","events","curves","unbox","stopAllHaptics","initializeEngine","destroyEngine","createContinuousPlayer","playerId","initialIntensity","initialSharpness","startContinuousPlayer","updateContinuousPlayer","intensityControl","sharpnessControl","stopContinuousPlayer","destroyContinuousPlayer","triggerImpact","style","triggerNotification","type","triggerSelection","setHapticsEnabled","enabled","getHapticsEnabled","useHapticsEnabled","setEnabled","setHapticsEnabledState","value","useContinuousPlayer","start","stop","update","intensity","sharpness","useHapticEngine","off","addEventListener","state","remove","HapticProvider","children"],"sourceRoot":"../../src","sources":["index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/src/Tickle.nitro.d.ts

@@ -0,0 +1,63 @@
+import type { HybridObject } from 'react-native-nitro-modules';
+export type HapticEventType = 'transient' | 'continuous';
+export type HapticParameterType = 'intensity' | 'sharpness';
+/**
+ * Feedback intensity styles for impact haptics.
+ * Maps to UIImpactFeedbackGenerator.FeedbackStyle on iOS.
+ */
+export type HapticImpactStyle = 'rigid' | 'heavy' | 'medium' | 'light' | 'soft';
+/**
+ * Notification feedback categories for alert-style haptics.
+ * Maps to UINotificationFeedbackGenerator.FeedbackType on iOS.
+ */
+export type HapticNotificationType = 'error' | 'success' | 'warning';
+export type HapticEventParameter = {
+    type: HapticParameterType;
+    value: number;
+};
+export type HapticCurveControlPoint = {
+    relativeTime: number;
+    value: number;
+};
+export type HapticEvent = {
+    type: HapticEventType;
+    parameters: HapticEventParameter[];
+    relativeTime: number;
+    duration?: number;
+};
+export type HapticCurve = {
+    type: HapticParameterType;
+    controlPoints: HapticCurveControlPoint[];
+    relativeTime: number;
+};
+export interface Tickle extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    startHaptic(events: HapticEvent[], curves: HapticCurve[]): void;
+    stopAllHaptics(): void;
+    initializeEngine(): void;
+    destroyEngine(): void;
+    createContinuousPlayer(playerId: string, initialIntensity: number, initialSharpness: number): void;
+    startContinuousPlayer(playerId: string): void;
+    updateContinuousPlayer(playerId: string, intensityControl: number, sharpnessControl: number): void;
+    stopContinuousPlayer(playerId: string): void;
+    destroyContinuousPlayer(playerId: string): void;
+    setHapticsEnabled(enabled: boolean): void;
+    getHapticsEnabled(): boolean;
+    /**
+     * Triggers an impact haptic with the specified style.
+     * Simulates a physical collision feedback.
+     */
+    triggerImpact(style: HapticImpactStyle): void;
+    /**
+     * Triggers a notification-style haptic for alerts and status updates.
+     */
+    triggerNotification(type: HapticNotificationType): void;
+    /**
+     * Triggers a selection change haptic.
+     * Best used for picker wheels, toggles, and selection changes.
+     */
+    triggerSelection(): void;
+}
+//# sourceMappingURL=Tickle.nitro.d.ts.map

package/lib/typescript/src/Tickle.nitro.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tickle.nitro.d.ts","sourceRoot":"","sources":["../../../src/Tickle.nitro.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE/D,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,YAAY,CAAC;AACzD,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,WAAW,CAAC;AAI5D;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,CAAC;AAEhF;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,OAAO,GAAG,SAAS,GAAG,SAAS,CAAC;AAErE,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,mBAAmB,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG;IACpC,YAAY,EAAE,MAAM,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,eAAe,CAAC;IACtB,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,mBAAmB,CAAC;IAC1B,aAAa,EAAE,uBAAuB,EAAE,CAAC;IACzC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,WAAW,MACf,SAAQ,YAAY,CAAC;IAAE,GAAG,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,QAAQ,CAAA;CAAE,CAAC;IACzD,WAAW,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,IAAI,CAAC;IAChE,cAAc,IAAI,IAAI,CAAC;IACvB,gBAAgB,IAAI,IAAI,CAAC;IACzB,aAAa,IAAI,IAAI,CAAC;IAEtB,sBAAsB,CACpB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAAC;IACR,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,sBAAsB,CACpB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAAC;IACR,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7C,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAEhD,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAAC;IAC1C,iBAAiB,IAAI,OAAO,CAAC;IAI7B;;;OAGG;IACH,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAE9C;;OAEG;IACH,mBAAmB,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAAC;IAExD;;;OAGG;IACH,gBAAgB,IAAI,IAAI,CAAC;CAC1B"}

package/lib/typescript/src/index.d.ts

@@ -0,0 +1,148 @@
+import type { Tickle, HapticCurve, HapticEventParameter, HapticParameterType, HapticImpactStyle, HapticNotificationType } from './Tickle.nitro';
+export type TransientHapticEvent = {
+    type: 'transient';
+    parameters: HapticEventParameter[];
+    relativeTime: number;
+};
+export type ContinuousHapticEvent = {
+    type: 'continuous';
+    parameters: HapticEventParameter[];
+    relativeTime: number;
+    duration: number;
+};
+export type HapticEvent = TransientHapticEvent | ContinuousHapticEvent;
+declare const TickleHybridObject: Tickle;
+export declare function startHaptic(events: HapticEvent[], curves: HapticCurve[]): void;
+export declare function stopAllHaptics(): void;
+export declare function initializeEngine(): void;
+export declare function destroyEngine(): void;
+export declare function createContinuousPlayer(playerId: string, initialIntensity: number, initialSharpness: number): void;
+export declare function startContinuousPlayer(playerId: string): void;
+export declare function updateContinuousPlayer(playerId: string, intensityControl: number, sharpnessControl: number): void;
+export declare function stopContinuousPlayer(playerId: string): void;
+export declare function destroyContinuousPlayer(playerId: string): void;
+/**
+ * Triggers an impact haptic with the specified style.
+ * Simulates a physical collision feedback.
+ *
+ * @param style - The intensity style of the impact ('rigid' | 'heavy' | 'medium' | 'light' | 'soft')
+ *
+ * @example
+ * ```ts
+ * // Light tap for subtle UI feedback
+ * triggerImpact('light');
+ *
+ * // Heavy impact for significant actions
+ * triggerImpact('heavy');
+ * ```
+ */
+export declare function triggerImpact(style: HapticImpactStyle): void;
+/**
+ * Triggers a notification-style haptic for alerts and status updates.
+ * Use this for communicating outcomes of actions to the user.
+ *
+ * @param type - The notification type ('error' | 'success' | 'warning')
+ *
+ * @example
+ * ```ts
+ * // Success feedback after completing an action
+ * triggerNotification('success');
+ *
+ * // Error feedback when something goes wrong
+ * triggerNotification('error');
+ * ```
+ */
+export declare function triggerNotification(type: HapticNotificationType): void;
+/**
+ * Triggers a selection change haptic.
+ * Best used for picker wheels, toggles, and selection changes.
+ *
+ * @example
+ * ```ts
+ * // When user scrolls through picker options
+ * triggerSelection();
+ * ```
+ */
+export declare function triggerSelection(): void;
+/**
+ * Enable or disable haptics globally. This setting is persisted across app restarts.
+ * When disabled, all haptic functions become no-ops (no haptics will play).
+ * This does not affect engine initialization/destruction.
+ *
+ * @param enabled - Whether haptics should be enabled
+ */
+export declare function setHapticsEnabled(enabled: boolean): void;
+/**
+ * Get the current global haptics enabled state.
+ * Defaults to true if not previously set.
+ *
+ * @returns Whether haptics are currently enabled
+ */
+export declare function getHapticsEnabled(): boolean;
+/**
+ * Hook to manage the global haptics enabled state.
+ * Provides reactive state and a setter function.
+ *
+ * @returns [isEnabled, setEnabled] - Current state and setter function
+ *
+ * @example
+ * ```tsx
+ * function SettingsScreen() {
+ *   const [hapticsEnabled, setHapticsEnabled] = useHapticsEnabled();
+ *
+ *   return (
+ *     <Switch
+ *       value={hapticsEnabled}
+ *       onValueChange={setHapticsEnabled}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export declare function useHapticsEnabled(): [boolean, (enabled: boolean) => void];
+/**
+ * Hook to manage a continuous haptic player lifecycle.
+ *
+ * @param playerId - A unique string key to identify this player (e.g., 'my-palette')
+ * @param initialIntensity - Initial intensity value (0.0 to 1.0)
+ * @param initialSharpness - Initial sharpness value (0.0 to 1.0)
+ *
+ * @returns Object with JS-bound methods for convenience:
+ * - `start()` - Start the continuous haptic
+ * - `stop()` - Stop the continuous haptic
+ * - `update(intensity, sharpness)` - Update haptic parameters
+ * - `playerId` - The player key (for use in worklets)
+ *
+ * @example
+ * ```tsx
+ * const PLAYER_KEY = 'my-palette';
+ *
+ * function MyComponent() {
+ *   const { start, stop, update } = useContinuousPlayer(PLAYER_KEY, 1.0, 0.5);
+ *
+ *   const gesture = Gesture.Pan()
+ *     .onBegin(() => {
+ *       start();
+ *     })
+ *     .onUpdate(() => {
+ *       update(0.5, 0.5);
+ *     })
+ *     .onEnd(() => {
+ *       stop();
+ *     });
+ * }
+ * ```
+ */
+export declare function useContinuousPlayer(playerId: string, initialIntensity?: number, initialSharpness?: number): {
+    start: () => void;
+    stop: () => void;
+    update: (intensity: number, sharpness: number) => void;
+    playerId: string;
+};
+export declare function useHapticEngine(): void;
+export declare function HapticProvider({ children }: {
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export { TickleHybridObject };
+export type { HapticCurve, HapticEventParameter, HapticParameterType, HapticImpactStyle, HapticNotificationType, };
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.tsx"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,MAAM,EACN,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,EACvB,MAAM,gBAAgB,CAAC;AAExB,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,WAAW,CAAC;IAClB,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,YAAY,CAAC;IACnB,UAAU,EAAE,oBAAoB,EAAE,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,oBAAoB,GAAG,qBAAqB,CAAC;AAEvE,QAAA,MAAM,kBAAkB,QAAoD,CAAC;AAI7E,wBAAgB,WAAW,CACzB,MAAM,EAAE,WAAW,EAAE,EACrB,MAAM,EAAE,WAAW,EAAE,GACpB,IAAI,CAIN;AAED,wBAAgB,cAAc,IAAI,IAAI,CAIrC;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAIvC;AAED,wBAAgB,aAAa,IAAI,IAAI,CAIpC;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAMN;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAI5D;AAED,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,GACvB,IAAI,CAMN;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAG3D;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAG9D;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAG5D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,sBAAsB,GAAG,IAAI,CAGtE;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,IAAI,IAAI,CAGvC;AAID;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAGxD;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAG3C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,iBAAiB,IAAI,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,CASzE;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,MAAM,EAChB,gBAAgB,GAAE,MAAY,EAC9B,gBAAgB,GAAE,MAAY;;;wBAmBR,MAAM,aAAa,MAAM;;EAMhD;AAED,wBAAgB,eAAe,SAgB9B;AAED,wBAAgB,cAAc,CAAC,EAAE,QAAQ,EAAE,EAAE;IAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;CAAE,2CAIzE;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAC9B,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,mBAAmB,EACnB,iBAAiB,EACjB,sBAAsB,GACvB,CAAC"}

package/nitro.json

@@ -0,0 +1,17 @@
+{
+  "cxxNamespace": ["tickle"],
+  "ios": {
+    "iosModuleName": "Tickle"
+  },
+  "android": {
+    "androidNamespace": ["tickle"],
+    "androidCxxLibName": "tickle"
+  },
+  "autolinking": {
+    "Tickle": {
+      "swift": "Tickle",
+      "kotlin": "Tickle"
+    }
+  },
+  "ignorePaths": ["node_modules", "example", "lib"]
+}

package/nitrogen/generated/android/c++/JHapticCurve.hpp

@@ -0,0 +1,87 @@
+///
+/// JHapticCurve.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HapticCurve.hpp"
+
+#include "HapticCurveControlPoint.hpp"
+#include "HapticParameterType.hpp"
+#include "JHapticCurveControlPoint.hpp"
+#include "JHapticParameterType.hpp"
+#include <vector>
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HapticCurve" and the the Kotlin data class "HapticCurve".
+   */
+  struct JHapticCurve final: public jni::JavaClass<JHapticCurve> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticCurve;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HapticCurve by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticCurve toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldType = clazz->getField<JHapticParameterType>("type");
+      jni::local_ref<JHapticParameterType> type = this->getFieldValue(fieldType);
+      static const auto fieldControlPoints = clazz->getField<jni::JArrayClass<JHapticCurveControlPoint>>("controlPoints");
+      jni::local_ref<jni::JArrayClass<JHapticCurveControlPoint>> controlPoints = this->getFieldValue(fieldControlPoints);
+      static const auto fieldRelativeTime = clazz->getField<double>("relativeTime");
+      double relativeTime = this->getFieldValue(fieldRelativeTime);
+      return HapticCurve(
+        type->toCpp(),
+        [&]() {
+          size_t __size = controlPoints->size();
+          std::vector<HapticCurveControlPoint> __vector;
+          __vector.reserve(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            auto __element = controlPoints->getElement(__i);
+            __vector.push_back(__element->toCpp());
+          }
+          return __vector;
+        }(),
+        relativeTime
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHapticCurve::javaobject> fromCpp(const HapticCurve& value) {
+      using JSignature = JHapticCurve(jni::alias_ref<JHapticParameterType>, jni::alias_ref<jni::JArrayClass<JHapticCurveControlPoint>>, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        JHapticParameterType::fromCpp(value.type),
+        [&]() {
+          size_t __size = value.controlPoints.size();
+          jni::local_ref<jni::JArrayClass<JHapticCurveControlPoint>> __array = jni::JArrayClass<JHapticCurveControlPoint>::newArray(__size);
+          for (size_t __i = 0; __i < __size; __i++) {
+            const auto& __element = value.controlPoints[__i];
+            auto __elementJni = JHapticCurveControlPoint::fromCpp(__element);
+            __array->setElement(__i, *__elementJni);
+          }
+          return __array;
+        }(),
+        value.relativeTime
+      );
+    }
+  };
+
+} // namespace margelo::nitro::tickle

package/nitrogen/generated/android/c++/JHapticCurveControlPoint.hpp

@@ -0,0 +1,61 @@
+///
+/// JHapticCurveControlPoint.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "HapticCurveControlPoint.hpp"
+
+
+
+namespace margelo::nitro::tickle {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "HapticCurveControlPoint" and the the Kotlin data class "HapticCurveControlPoint".
+   */
+  struct JHapticCurveControlPoint final: public jni::JavaClass<JHapticCurveControlPoint> {
+  public:
+    static auto constexpr kJavaDescriptor = "Lcom/margelo/nitro/tickle/HapticCurveControlPoint;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct HapticCurveControlPoint by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    HapticCurveControlPoint toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldRelativeTime = clazz->getField<double>("relativeTime");
+      double relativeTime = this->getFieldValue(fieldRelativeTime);
+      static const auto fieldValue = clazz->getField<double>("value");
+      double value = this->getFieldValue(fieldValue);
+      return HapticCurveControlPoint(
+        relativeTime,
+        value
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JHapticCurveControlPoint::javaobject> fromCpp(const HapticCurveControlPoint& value) {
+      using JSignature = JHapticCurveControlPoint(double, double);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.relativeTime,
+        value.value
+      );
+    }
+  };
+
+} // namespace margelo::nitro::tickle