@sayparlo/react-native 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,127 @@
-# Temporary Holding Version
+# @sayparlo/react-native
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Voice feedback and help requests for Expo and React Native apps, powered by [Parlo](https://sayparlo.com).
+
+Your users tap a button, speak (or type), and the feedback lands in your Parlo inbox, transcribed, summarized and sorted.
+
+## Requirements
+
+- Expo SDK 53 or newer (or a bare React Native app with Expo modules)
+- An app added in Parlo: **Sites → Add → Mobile app**, to get its key (`pk_…`)
+
+## Install
+
+```sh
+npx expo install @sayparlo/react-native expo-audio expo-application expo-device
+```
+
+Declare the microphone in `app.json`, then rebuild your development build:
+
+```json
+{
+  "expo": {
+    "plugins": [["expo-audio", { "microphonePermission": "Allow $(PRODUCT_NAME) to use the microphone for voice feedback." }]]
+  }
+}
+```
+
+## Usage
+
+Wrap your app once, at the root (`App.tsx`, or `app/_layout.tsx` with Expo Router):
+
+```tsx
+import { ParloProvider } from '@sayparlo/react-native'
+
+export default function App() {
+  return (
+    <ParloProvider siteKey="pk_your_key" apiUrl="https://parlo.threading.site" showButton>
+      <Navigation />
+    </ParloProvider>
+  )
+}
+```
+
+`showButton` displays a floating "Give feedback" button. To open Parlo from your own buttons:
+
+```tsx
+import { useParlo } from '@sayparlo/react-native'
+
+function Settings() {
+  const parlo = useParlo()
+  return (
+    <>
+      <Button title="Give feedback" onPress={() => parlo.open()} />
+      <Button title="Get help" onPress={() => parlo.open({ intent: 'support' })} />
+    </>
+  )
+}
+```
+
+## Identify your users
+
+```tsx
+const parlo = useParlo()
+
+useEffect(() => {
+  parlo.identify(user ? { id: user.id, email: user.email, name: user.name, hash: user.parloHash } : null)
+}, [user])
+```
+
+`hash` proves the identity: compute it **on your server**, as the HMAC-SHA256 of the user id with the secret shown in Parlo (Sites → your app → Identification). Never ship the secret in the app.
+
+```js
+// Node.js, on your server
+const hash = createHmac('sha256', PARLO_IDENTITY_SECRET).update(String(user.id)).digest('hex')
+```
+
+## Context, screen and version
+
+```tsx
+parlo.setContext({ plan: 'pro', account: 'Acme' }) // 20 keys at most: text, number or boolean
+parlo.setScreen('Checkout') // shown as the "page" of the feedback
+parlo.setVersion('2.4.1') // read from the native build by default
+```
+
+With Expo Router, follow the current route:
+
+```tsx
+const pathname = usePathname()
+useEffect(() => parlo.setScreen(pathname), [pathname])
+```
+
+## Screenshots
+
+Install `react-native-view-shot` and pass a capture function: users can then attach a screenshot of the app to their feedback.
+
+```tsx
+import { captureScreen } from 'react-native-view-shot'
+
+<ParloProvider siteKey="pk_your_key" captureScreen={() => captureScreen({ format: 'jpg', quality: 0.7 })}>
+```
+
+## Props
+
+| Prop | Default | |
+| --- | --- | --- |
+| `siteKey` | (required) | Key of the app in Parlo |
+| `apiUrl` | `https://parlo.threading.site` | Address of Parlo |
+| `showButton` | `false` | Floating "Give feedback" button |
+| `buttonPosition` | `bottom-right` | Or `bottom-left` |
+| `user` | | Signed-in user (same as `identify`) |
+| `context` | | Context sent with each feedback |
+| `version` | native version | App version |
+| `locale` | Parlo setting, then device | `fr`, `en`, `es`, `de`, `it`, `pt`, `nl` |
+| `testMode` | `__DEV__` | Marks feedbacks as tests (left out of statistics) |
+| `captureScreen` | | Enables screenshots |
+| `appId` | bundle id | Shown in the "page" of feedbacks |
+
+Colour, question and language are set in Parlo (Sites → your app → Appearance) and apply without a new release.
+
+## Privacy
+
+The microphone is only requested when the user taps "Speak". No device identifier is collected: feedbacks carry the device model, OS version, app version and what you pass yourself.
+
+## Releasing (maintainers)
+
+1. Bump `version` in `package.json`, merge to `main`.
+2. Create a GitHub release with the tag `vX.Y.Z`: the **Publish to npm** workflow publishes it with npm trusted publishing (no token).

package/lib/FeedbackSheet.d.ts

@@ -0,0 +1,26 @@
+import type { Client } from './api';
+import type { Strings } from './i18n';
+import type { ParloContext, ParloIntent, ParloRemoteConfig, ParloUser } from './types';
+export type SheetSession = {
+    user: ParloUser | null;
+    context: ParloContext | null;
+    version: string | null;
+    screen: string | null;
+    appId: string;
+    device: string;
+    locale: string;
+    isTest: boolean;
+};
+type Props = {
+    visible: boolean;
+    onClose: () => void;
+    intent: ParloIntent;
+    onIntent: (intent: ParloIntent) => void;
+    config: ParloRemoteConfig | null;
+    strings: Strings;
+    client: Client;
+    getSession: () => SheetSession;
+    captureScreen?: () => Promise<string>;
+};
+export declare function FeedbackSheet({ visible, onClose, intent, onIntent, config, strings: t, client, getSession, captureScreen }: Props): import("react").JSX.Element;
+export {};

package/lib/FeedbackSheet.js

@@ -0,0 +1,280 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { AudioModule, RecordingPresets, setAudioModeAsync, useAudioPlayer, useAudioPlayerStatus, useAudioRecorder, useAudioRecorderState, } from 'expo-audio';
+import { useEffect, useRef, useState } from 'react';
+import { ActivityIndicator, Animated, Image, KeyboardAvoidingView, Linking, Modal, Platform, Pressable, ScrollView, StyleSheet, Text, TextInput, View, } from 'react-native';
+const RECORDING = { ...RecordingPresets.HIGH_QUALITY, numberOfChannels: 1, bitRate: 64000 };
+const INK = '#2B2926';
+const MUTED = '#5E5A55';
+const BORDER = '#E2DED8';
+const DANGER = '#C9533F';
+function fmt(ms) {
+    const s = Math.max(0, Math.round(ms / 1000));
+    return `${Math.floor(s / 60)}:${String(s % 60).padStart(2, '0')}`;
+}
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+function file(uri, name, type) {
+    return { uri, name, type };
+}
+export function FeedbackSheet({ visible, onClose, intent, onIntent, config, strings: t, client, getSession, captureScreen }) {
+    const color = /^#[0-9a-f]{3,8}$/i.test(config?.color ?? '') ? config?.color : INK;
+    const maxMs = (config?.maxSeconds ?? 90) * 1000;
+    const support = intent === 'support' && config?.support !== false;
+    const recorder = useAudioRecorder(RECORDING);
+    const recorderState = useAudioRecorderState(recorder, 250);
+    const player = useAudioPlayer(null);
+    const playerStatus = useAudioPlayerStatus(player);
+    const [view, setView] = useState('intro');
+    const [audio, setAudio] = useState(null);
+    const [text, setText] = useState('');
+    const [email, setEmail] = useState('');
+    const [shot, setShot] = useState(null);
+    const [error, setError] = useState('');
+    const [failures, setFailures] = useState(0);
+    const [micBlocked, setMicBlocked] = useState(false);
+    const [hidden, setHidden] = useState(false);
+    const [trackingUrl, setTrackingUrl] = useState(null);
+    const startedAt = useRef(0);
+    const retryView = useRef('text');
+    const pulse = useRef(new Animated.Value(1)).current;
+    useEffect(() => {
+        if (visible && view === 'thanks') {
+            setView('intro');
+            setTrackingUrl(null);
+            setError('');
+        }
+    }, [visible]);
+    useEffect(() => {
+        if (view === 'recording' && recorderState.durationMillis >= maxMs)
+            void stopRecording(false);
+    }, [recorderState.durationMillis, view]);
+    useEffect(() => {
+        if (view !== 'recording')
+            return;
+        const loop = Animated.loop(Animated.sequence([
+            Animated.timing(pulse, { toValue: 0.3, duration: 500, useNativeDriver: true }),
+            Animated.timing(pulse, { toValue: 1, duration: 500, useNativeDriver: true }),
+        ]));
+        loop.start();
+        return () => loop.stop();
+    }, [view, pulse]);
+    async function startRecording() {
+        setError('');
+        try {
+            const permission = await AudioModule.requestRecordingPermissionsAsync();
+            if (!permission.granted) {
+                client.event('mic_denied');
+                setMicBlocked(true);
+                setView('text');
+                return;
+            }
+            await setAudioModeAsync({ allowsRecording: true, playsInSilentMode: true });
+            await recorder.prepareToRecordAsync();
+            recorder.record();
+            startedAt.current = Date.now();
+            setView('recording');
+        }
+        catch {
+            setMicBlocked(true);
+            setView('text');
+        }
+    }
+    async function stopRecording(discard) {
+        const durationMs = Date.now() - startedAt.current;
+        try {
+            await recorder.stop();
+        }
+        catch {
+        }
+        await setAudioModeAsync({ allowsRecording: false, playsInSilentMode: true }).catch(() => { });
+        if (discard) {
+            setView('intro');
+            return;
+        }
+        const uri = recorder.uri;
+        if (!uri || durationMs < 1200) {
+            setError(t.tooShort);
+            setView('intro');
+            return;
+        }
+        setAudio({ uri, durationMs: Math.min(durationMs, maxMs + 2000) });
+        player.replace({ uri });
+        setView('review');
+    }
+    function togglePlay() {
+        if (playerStatus.playing) {
+            player.pause();
+            return;
+        }
+        if (playerStatus.duration > 0 && playerStatus.currentTime >= playerStatus.duration - 0.1)
+            void player.seekTo(0);
+        player.play();
+    }
+    async function attachScreenshot() {
+        if (!captureScreen)
+            return;
+        setError('');
+        setHidden(true);
+        await wait(500);
+        try {
+            setShot(await captureScreen());
+        }
+        catch {
+            setError(t.shotFailed);
+        }
+        finally {
+            setHidden(false);
+        }
+    }
+    async function send(fromView) {
+        setError('');
+        const audioMode = fromView === 'review' && audio !== null;
+        const s = getSession();
+        const form = new FormData();
+        if (audioMode && audio) {
+            form.append('audio', file(audio.uri, 'retour.m4a', 'audio/mp4'));
+            form.append('durationMs', String(Math.min(audio.durationMs, 95000)));
+        }
+        else {
+            const body = text.trim();
+            if (!body) {
+                setError(t.emptyText);
+                return;
+            }
+            form.append('text', body.slice(0, 4000));
+        }
+        if (shot && config?.screenshots !== false)
+            form.append('screenshot', file(shot, 'capture.jpg', 'image/jpeg'));
+        form.append('pageUrl', `app://${s.appId}${s.screen ? `/${encodeURIComponent(s.screen)}` : ''}`);
+        form.append('locale', s.locale);
+        if (s.user?.id) {
+            form.append('endUserId', String(s.user.id));
+            if (s.user.name)
+                form.append('endUserName', s.user.name);
+            if (s.user.hash)
+                form.append('userHash', s.user.hash);
+        }
+        if (s.user?.email)
+            form.append('userEmail', s.user.email);
+        if (email.trim())
+            form.append('contactEmail', email.trim());
+        if (s.context)
+            form.append('context', JSON.stringify(s.context).slice(0, 4000));
+        if (s.version)
+            form.append('appVersion', s.version.slice(0, 40));
+        form.append('device', s.device);
+        if (s.isTest)
+            form.append('isTest', '1');
+        if (support)
+            form.append('intent', 'support');
+        retryView.current = audioMode ? 'review' : 'text';
+        setView('sending');
+        const result = await client.submit(form);
+        if (result.ok) {
+            player.pause();
+            setAudio(null);
+            setText('');
+            setShot(null);
+            setFailures(0);
+            setTrackingUrl(result.trackingUrl);
+            setView('thanks');
+            return;
+        }
+        setFailures((n) => n + 1);
+        setError(result.message ?? t.failed);
+        setView('error');
+    }
+    function close() {
+        if (view === 'recording')
+            void stopRecording(true);
+        player.pause();
+        onClose();
+    }
+    const question = support ? t.helpQuestion : config && !config.questionIsDefault && config.question ? config.question : t.defaultQuestion;
+    const knowsEmail = Boolean(getSession().user?.email);
+    const segmented = config?.support === false ? null : (_jsx(View, { style: styles.seg, children: ['feedback', 'support'].map((value) => {
+            const active = (value === 'support') === support;
+            return (_jsx(Pressable, { onPress: () => onIntent(value), style: [styles.segItem, active && styles.segActive], accessibilityRole: "button", accessibilityState: { selected: active }, children: _jsx(Text, { style: [styles.segText, active && styles.segTextActive], children: value === 'support' ? t.chooseHelp : t.chooseFeedback }) }, value));
+        }) }));
+    const primary = (label, onPress, flex) => (_jsx(Pressable, { onPress: onPress, style: [styles.primary, { backgroundColor: color }, flex && styles.flex], accessibilityRole: "button", children: _jsx(Text, { style: styles.primaryText, children: label }) }));
+    const secondary = (label, onPress) => (_jsx(Pressable, { onPress: onPress, style: [styles.secondary, styles.flex], accessibilityRole: "button", children: _jsx(Text, { style: styles.secondaryText, children: label }) }));
+    const link = (label, onPress) => (_jsx(Pressable, { onPress: onPress, style: styles.linkWrap, accessibilityRole: "button", children: _jsx(Text, { style: styles.link, children: label }) }));
+    const shotBlock = config?.screenshots === false || !captureScreen ? null : shot ? (_jsxs(View, { style: styles.shot, children: [_jsx(Image, { source: { uri: shot }, style: styles.shotImage }), _jsx(Text, { style: styles.note, children: t.shotLabel }), _jsx(Pressable, { onPress: () => setShot(null), style: styles.shotRemove, children: _jsx(Text, { style: styles.danger, children: t.removeShot }) })] })) : (_jsx(Pressable, { onPress: () => void attachScreenshot(), style: styles.attach, accessibilityRole: "button", children: _jsx(Text, { style: styles.attachText, children: t.attachScreen }) }));
+    const emailField = knowsEmail ? null : (_jsxs(View, { style: styles.field, children: [_jsx(Text, { style: styles.label, children: support ? t.helpEmail : t.email }), _jsx(TextInput, { value: email, onChangeText: setEmail, keyboardType: "email-address", autoCapitalize: "none", autoComplete: "email", autoCorrect: false, maxLength: 254, style: styles.input })] }));
+    const errorText = error ? (_jsx(Text, { style: [styles.note, styles.danger], accessibilityRole: "alert", children: error })) : null;
+    let body = null;
+    if (view === 'intro') {
+        body = (_jsxs(_Fragment, { children: [segmented, _jsxs(Text, { style: styles.consent, children: [t.consent, ' ', _jsx(Text, { style: styles.consentLink, onPress: () => void Linking.openURL(client.url('/confidentialite')), children: t.privacy })] }), primary(`🎙  ${t.talk}`, () => void startRecording()), errorText, link(t.write, () => setView('text'))] }));
+    }
+    else if (view === 'recording') {
+        body = (_jsxs(_Fragment, { children: [_jsxs(View, { style: styles.recRow, children: [_jsx(Animated.View, { style: [styles.dot, { opacity: pulse }] }), _jsxs(Text, { style: styles.time, children: [fmt(recorderState.durationMillis), " / ", fmt(maxMs)] })] }), primary(t.stop, () => void stopRecording(false))] }));
+    }
+    else if (view === 'review') {
+        body = (_jsxs(_Fragment, { children: [_jsxs(Pressable, { onPress: togglePlay, style: styles.player, accessibilityRole: "button", children: [_jsx(Text, { style: [styles.playIcon, { color }], children: playerStatus.playing ? '❚❚' : '▶' }), _jsx(Text, { style: styles.playerText, children: playerStatus.playing ? t.pause : t.play }), _jsx(Text, { style: styles.time, children: fmt(audio?.durationMs ?? 0) })] }), shotBlock, emailField, errorText, _jsxs(View, { style: styles.row, children: [secondary(t.redo, () => {
+                            setAudio(null);
+                            void startRecording();
+                        }), primary(t.send, () => void send('review'), true)] })] }));
+    }
+    else if (view === 'text') {
+        body = (_jsxs(_Fragment, { children: [segmented, micBlocked ? _jsx(Text, { style: styles.note, children: t.micUnavailable }) : null, _jsx(TextInput, { value: text, onChangeText: setText, placeholder: support ? t.helpPlaceholder : t.textPlaceholder, placeholderTextColor: "#8F8A84", multiline: true, maxLength: 4000, style: [styles.input, styles.textarea], textAlignVertical: "top" }), shotBlock, emailField, errorText, primary(t.send, () => void send('text')), micBlocked ? null : link(t.backToVoice, () => void startRecording())] }));
+    }
+    else if (view === 'sending') {
+        body = (_jsxs(View, { style: styles.center, children: [_jsx(ActivityIndicator, { color: color }), _jsx(Text, { style: styles.note, children: t.sending })] }));
+    }
+    else if (view === 'error') {
+        body = (_jsxs(_Fragment, { children: [errorText, primary(t.retry, () => void send(retryView.current)), failures >= 3 && audio ? link(t.switchToText, () => setView('text')) : null] }));
+    }
+    else if (view === 'thanks') {
+        body = (_jsxs(View, { style: styles.center, children: [_jsx(Text, { style: styles.big, children: support ? t.helpThanks : t.thanks }), _jsx(Text, { style: styles.note, children: support ? t.helpThanksSub : t.thanksSub }), trackingUrl && /^https:\/\//.test(trackingUrl) ? link(`${t.track} ↗`, () => void Linking.openURL(trackingUrl)) : null] }));
+    }
+    return (_jsx(Modal, { visible: visible && !hidden, transparent: true, animationType: "slide", onRequestClose: close, statusBarTranslucent: true, children: _jsxs(KeyboardAvoidingView, { behavior: Platform.OS === 'ios' ? 'padding' : undefined, style: styles.flex, children: [_jsx(Pressable, { style: styles.backdrop, onPress: close, accessibilityLabel: t.close }), _jsxs(View, { style: styles.sheet, children: [_jsxs(View, { style: styles.header, children: [_jsx(Text, { style: styles.question, children: view === 'thanks' ? '' : question }), _jsx(Pressable, { onPress: close, hitSlop: 12, accessibilityRole: "button", accessibilityLabel: t.close, children: _jsx(Text, { style: styles.closeIcon, children: "\u00D7" }) })] }), _jsxs(ScrollView, { keyboardShouldPersistTaps: "handled", bounces: false, children: [body, config?.branding ? (_jsx(Text, { style: styles.brand, onPress: () => void Linking.openURL(client.url('/decouvrir?ref=app')), children: t.brand })) : null] })] })] }) }));
+}
+const styles = StyleSheet.create({
+    flex: { flex: 1 },
+    backdrop: { flex: 1, backgroundColor: 'rgba(0,0,0,0.35)' },
+    sheet: {
+        backgroundColor: '#fff',
+        borderTopLeftRadius: 18,
+        borderTopRightRadius: 18,
+        paddingHorizontal: 20,
+        paddingTop: 18,
+        paddingBottom: 34,
+        maxHeight: '88%',
+    },
+    header: { flexDirection: 'row', alignItems: 'flex-start', gap: 12, marginBottom: 6 },
+    question: { flex: 1, fontSize: 17, fontWeight: '600', color: INK, lineHeight: 23 },
+    closeIcon: { fontSize: 26, lineHeight: 26, color: '#8F8A84' },
+    seg: { flexDirection: 'row', gap: 4, padding: 3, backgroundColor: '#F4F2EE', borderRadius: 10, marginTop: 10 },
+    segItem: { flex: 1, paddingVertical: 8, borderRadius: 8, alignItems: 'center' },
+    segActive: { backgroundColor: '#fff', shadowColor: '#000', shadowOpacity: 0.08, shadowRadius: 3, shadowOffset: { width: 0, height: 1 }, elevation: 1 },
+    segText: { fontSize: 13.5, fontWeight: '500', color: MUTED },
+    segTextActive: { color: INK },
+    consent: { fontSize: 12.5, color: MUTED, marginVertical: 14, lineHeight: 18 },
+    consentLink: { textDecorationLine: 'underline' },
+    primary: { borderRadius: 11, paddingVertical: 14, paddingHorizontal: 16, alignItems: 'center', marginTop: 12 },
+    primaryText: { color: '#fff', fontSize: 15.5, fontWeight: '600' },
+    secondary: { borderRadius: 11, paddingVertical: 13, alignItems: 'center', marginTop: 12, borderWidth: 1, borderColor: BORDER },
+    secondaryText: { color: INK, fontSize: 15, fontWeight: '500' },
+    row: { flexDirection: 'row', gap: 8 },
+    linkWrap: { alignSelf: 'center', marginTop: 12, padding: 4 },
+    link: { color: MUTED, fontSize: 14, textDecorationLine: 'underline' },
+    recRow: { flexDirection: 'row', alignItems: 'center', gap: 10, marginVertical: 22, justifyContent: 'center' },
+    dot: { width: 11, height: 11, borderRadius: 6, backgroundColor: DANGER },
+    time: { fontSize: 14, color: '#8F8A84', fontVariant: ['tabular-nums'] },
+    player: { flexDirection: 'row', alignItems: 'center', gap: 12, marginTop: 14, padding: 14, borderWidth: 1, borderColor: BORDER, borderRadius: 11 },
+    playIcon: { fontSize: 18, width: 22, textAlign: 'center' },
+    playerText: { flex: 1, fontSize: 15, color: INK },
+    field: { marginTop: 14 },
+    label: { fontSize: 12.5, color: MUTED, marginBottom: 6 },
+    input: { borderWidth: 1, borderColor: BORDER, borderRadius: 9, paddingHorizontal: 12, paddingVertical: 10, fontSize: 15, color: INK },
+    textarea: { minHeight: 120, marginTop: 14 },
+    note: { fontSize: 13, color: MUTED, marginTop: 10, lineHeight: 18 },
+    danger: { color: DANGER },
+    attach: { marginTop: 12, borderWidth: 1, borderStyle: 'dashed', borderColor: '#D6D1CA', borderRadius: 9, paddingVertical: 10, alignItems: 'center' },
+    attachText: { fontSize: 13.5, color: MUTED },
+    shot: { flexDirection: 'row', alignItems: 'center', gap: 10, marginTop: 12 },
+    shotImage: { width: 44, height: 72, borderRadius: 6, borderWidth: 1, borderColor: '#ECE9E4' },
+    shotRemove: { marginLeft: 'auto', padding: 4 },
+    center: { alignItems: 'center', paddingVertical: 20, gap: 4 },
+    big: { fontSize: 17, fontWeight: '600', color: INK, textAlign: 'center' },
+    brand: { marginTop: 16, textAlign: 'center', fontSize: 11.5, color: '#8F8A84' },
+});

package/lib/ParloProvider.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+import type { ParloApi, ParloContext, ParloUser } from './types';
+export type ParloProviderProps = {
+    siteKey: string;
+    apiUrl?: string;
+    user?: ParloUser | null;
+    context?: ParloContext | null;
+    version?: string;
+    locale?: string;
+    showButton?: boolean;
+    buttonPosition?: 'bottom-right' | 'bottom-left';
+    testMode?: boolean;
+    captureScreen?: () => Promise<string>;
+    appId?: string;
+    children: ReactNode;
+};
+export declare function useParlo(): ParloApi;
+export declare function ParloProvider({ siteKey, apiUrl, user, context, version, locale, showButton, buttonPosition, testMode, captureScreen, appId, children, }: ParloProviderProps): import("react").JSX.Element;

package/lib/ParloProvider.js

@@ -0,0 +1,125 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as Application from 'expo-application';
+import * as Device from 'expo-device';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState } from 'react';
+import { Platform, Pressable, StyleSheet, Text } from 'react-native';
+import { Client, DEFAULT_API_URL } from './api';
+import { FeedbackSheet } from './FeedbackSheet';
+import { pickStrings } from './i18n';
+const ParloReactContext = createContext(null);
+export function useParlo() {
+    const value = useContext(ParloReactContext);
+    if (!value)
+        throw new Error('useParlo() must be used inside <ParloProvider>.');
+    return value;
+}
+function deviceLabel() {
+    const kind = Device.deviceType === Device.DeviceType.TABLET ? 'Tablette' : 'Mobile';
+    const os = Platform.OS === 'ios' ? 'iOS' : Platform.OS === 'android' ? 'Android' : Platform.OS;
+    return [kind, `${os}${Device.osVersion ? ` ${Device.osVersion}` : ''}`, Device.modelName]
+        .filter(Boolean)
+        .join(' · ')
+        .slice(0, 120);
+}
+function deviceLocale() {
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().locale || '';
+    }
+    catch {
+        return '';
+    }
+}
+export function ParloProvider({ siteKey, apiUrl = DEFAULT_API_URL, user, context, version, locale, showButton = false, buttonPosition = 'bottom-right', testMode, captureScreen, appId, children, }) {
+    const client = useMemo(() => new Client(apiUrl, siteKey), [apiUrl, siteKey]);
+    const [config, setConfig] = useState(null);
+    const [visible, setVisible] = useState(false);
+    const [buttonHidden, setButtonHidden] = useState(false);
+    const [intent, setIntent] = useState('feedback');
+    const opened = useRef(false);
+    const userRef = useRef(user ?? null);
+    const contextRef = useRef(context ?? null);
+    const versionRef = useRef(version ?? Application.nativeApplicationVersion ?? null);
+    const screenRef = useRef(null);
+    useEffect(() => {
+        if (user !== undefined)
+            userRef.current = user;
+    }, [user]);
+    useEffect(() => {
+        if (context !== undefined)
+            contextRef.current = context;
+    }, [context]);
+    useEffect(() => {
+        if (version !== undefined)
+            versionRef.current = version;
+    }, [version]);
+    useEffect(() => {
+        let cancelled = false;
+        client.ping();
+        void client.config().then((c) => {
+            if (!cancelled)
+                setConfig(c);
+        });
+        return () => {
+            cancelled = true;
+        };
+    }, [client]);
+    const open = useCallback((options) => {
+        if (options?.intent)
+            setIntent(options.intent);
+        if (!opened.current) {
+            opened.current = true;
+            client.event('opened');
+        }
+        setVisible(true);
+    }, [client]);
+    const api = useMemo(() => ({
+        open,
+        close: () => setVisible(false),
+        identify: (next) => {
+            userRef.current = next;
+        },
+        logout: () => {
+            userRef.current = null;
+        },
+        setContext: (next) => {
+            contextRef.current = next;
+        },
+        setVersion: (next) => {
+            versionRef.current = next;
+        },
+        setScreen: (next) => {
+            screenRef.current = next;
+        },
+        ready: config !== null,
+    }), [open, config]);
+    const getSession = useCallback(() => ({
+        user: userRef.current,
+        context: contextRef.current,
+        version: versionRef.current,
+        screen: screenRef.current,
+        appId: (appId || Application.applicationId || 'app').replace(/[^a-zA-Z0-9._-]/g, ''),
+        device: deviceLabel(),
+        locale: locale || deviceLocale(),
+        isTest: testMode ?? (typeof __DEV__ !== 'undefined' && __DEV__ === true),
+    }), [appId, locale, testMode]);
+    const strings = pickStrings(locale, config?.locale);
+    const color = /^#[0-9a-f]{3,8}$/i.test(config?.color ?? '') ? config?.color : '#2B2926';
+    return (_jsxs(ParloReactContext.Provider, { value: api, children: [children, showButton && !buttonHidden && !visible ? (_jsx(Pressable, { onPress: () => open(), onLongPress: () => setButtonHidden(true), style: [styles.button, buttonPosition === 'bottom-left' ? styles.left : styles.right, { backgroundColor: color }], accessibilityRole: "button", accessibilityLabel: strings.button, children: _jsxs(Text, { style: styles.buttonText, children: ["\uD83C\uDF99 ", strings.button] }) })) : null, _jsx(FeedbackSheet, { visible: visible, onClose: () => setVisible(false), intent: intent, onIntent: setIntent, config: config, strings: strings, client: client, getSession: getSession, captureScreen: captureScreen })] }));
+}
+const styles = StyleSheet.create({
+    button: {
+        position: 'absolute',
+        bottom: 34,
+        borderRadius: 999,
+        paddingVertical: 12,
+        paddingHorizontal: 16,
+        shadowColor: '#000',
+        shadowOpacity: 0.18,
+        shadowRadius: 10,
+        shadowOffset: { width: 0, height: 4 },
+        elevation: 6,
+    },
+    right: { right: 18 },
+    left: { left: 18 },
+    buttonText: { color: '#fff', fontSize: 14.5, fontWeight: '600' },
+});

package/lib/api.d.ts

@@ -0,0 +1,21 @@
+import type { ParloRemoteConfig } from './types';
+export declare const DEFAULT_API_URL = "https://parlo.threading.site";
+export type SubmitResult = {
+    ok: true;
+    trackingUrl: string | null;
+} | {
+    ok: false;
+    message?: string;
+};
+export declare class Client {
+    private readonly siteKey;
+    private readonly base;
+    constructor(apiUrl: string, siteKey: string);
+    url(path: string): string;
+    private endpoint;
+    config(): Promise<ParloRemoteConfig | null>;
+    ping(): void;
+    event(type: 'opened' | 'mic_denied'): void;
+    private post;
+    submit(form: FormData): Promise<SubmitResult>;
+}

package/lib/api.js

@@ -0,0 +1,50 @@
+export const DEFAULT_API_URL = 'https://parlo.threading.site';
+export class Client {
+    constructor(apiUrl, siteKey) {
+        this.siteKey = siteKey;
+        this.base = apiUrl.replace(/\/+$/, '');
+    }
+    url(path) {
+        return `${this.base}${path}`;
+    }
+    endpoint(path) {
+        return `${this.base}/api/v1/widget/${encodeURIComponent(this.siteKey)}${path}`;
+    }
+    async config() {
+        try {
+            const response = await fetch(this.endpoint('/config'));
+            if (!response.ok)
+                return null;
+            return (await response.json());
+        }
+        catch {
+            return null;
+        }
+    }
+    ping() {
+        this.post('/ping', {});
+    }
+    event(type) {
+        this.post('/event', { type });
+    }
+    post(path, body) {
+        fetch(this.endpoint(path), {
+            method: 'POST',
+            headers: { 'content-type': 'text/plain' },
+            body: JSON.stringify(body),
+        }).catch(() => { });
+    }
+    async submit(form) {
+        try {
+            const response = await fetch(this.endpoint('/feedback'), { method: 'POST', body: form });
+            const data = (await response.json().catch(() => null));
+            if (response.status === 202) {
+                return { ok: true, trackingUrl: typeof data?.trackingUrl === 'string' ? data.trackingUrl : null };
+            }
+            return { ok: false, message: typeof data?.message === 'string' ? data.message : undefined };
+        }
+        catch {
+            return { ok: false };
+        }
+    }
+}

package/lib/i18n.d.ts

@@ -0,0 +1,41 @@
+export type Strings = {
+    button: string;
+    close: string;
+    chooseFeedback: string;
+    chooseHelp: string;
+    consent: string;
+    privacy: string;
+    talk: string;
+    write: string;
+    backToVoice: string;
+    stop: string;
+    play: string;
+    pause: string;
+    redo: string;
+    send: string;
+    email: string;
+    helpEmail: string;
+    attachScreen: string;
+    removeShot: string;
+    shotLabel: string;
+    shotFailed: string;
+    textPlaceholder: string;
+    helpPlaceholder: string;
+    micUnavailable: string;
+    sending: string;
+    thanks: string;
+    thanksSub: string;
+    helpThanks: string;
+    helpThanksSub: string;
+    failed: string;
+    retry: string;
+    switchToText: string;
+    tooShort: string;
+    emptyText: string;
+    track: string;
+    brand: string;
+    defaultQuestion: string;
+    helpQuestion: string;
+};
+export declare const STRINGS: Record<'fr' | 'en' | 'es' | 'de' | 'it' | 'pt' | 'nl', Strings>;
+export declare function pickStrings(forced: string | undefined, remote: string | undefined): Strings;

package/lib/i18n.js

@@ -0,0 +1,287 @@
+export const STRINGS = {
+    fr: {
+        button: 'Donner mon avis',
+        close: 'Fermer',
+        chooseFeedback: 'Donner un avis',
+        chooseHelp: "Demander de l'aide",
+        consent: "Votre voix est enregistrée puis transcrite pour aider l'équipe. Elle ne sert jamais à vous identifier.",
+        privacy: 'Confidentialité',
+        talk: 'Parler',
+        write: 'Je préfère écrire',
+        backToVoice: 'Revenir à la voix',
+        stop: 'Terminer',
+        play: 'Réécouter',
+        pause: 'Pause',
+        redo: 'Recommencer',
+        send: 'Envoyer',
+        email: "Votre e-mail (facultatif, pour qu'on puisse vous répondre)",
+        helpEmail: 'Votre e-mail, pour recevoir notre réponse',
+        attachScreen: "Joindre une capture de l'écran",
+        removeShot: 'Retirer',
+        shotLabel: 'Capture jointe',
+        shotFailed: "La capture n'a pas pu être faite.",
+        textPlaceholder: 'Dites-nous ce que vous pensez…',
+        helpPlaceholder: 'Expliquez ce qui vous bloque…',
+        micUnavailable: "Le micro n'est pas disponible : vous pouvez nous écrire à la place.",
+        sending: 'Envoi…',
+        thanks: 'Merci ! Votre retour a bien été envoyé.',
+        thanksSub: "L'équipe le lira très vite.",
+        helpThanks: 'Merci ! Votre demande a bien été envoyée.',
+        helpThanksSub: 'Nous vous répondrons dès que possible.',
+        failed: "L'envoi a échoué. Votre enregistrement est conservé.",
+        retry: 'Réessayer',
+        switchToText: "Passer à l'écrit",
+        tooShort: 'Enregistrement trop court, réessayez.',
+        emptyText: 'Écrivez quelques mots avant d’envoyer.',
+        track: 'Suivre mon retour',
+        brand: 'Propulsé par Parlo',
+        defaultQuestion: 'Une remarque, une idée ? Dites-le-nous à voix haute.',
+        helpQuestion: 'Décrivez votre problème, nous allons vous aider.',
+    },
+    en: {
+        button: 'Give feedback',
+        close: 'Close',
+        chooseFeedback: 'Give feedback',
+        chooseHelp: 'Get help',
+        consent: 'Your voice is recorded and transcribed to help the team. It is never used to identify you.',
+        privacy: 'Privacy',
+        talk: 'Speak',
+        write: "I'd rather type",
+        backToVoice: 'Back to voice',
+        stop: 'Done',
+        play: 'Listen',
+        pause: 'Pause',
+        redo: 'Start over',
+        send: 'Send',
+        email: 'Your email (optional, so we can reply)',
+        helpEmail: 'Your email, to get our answer',
+        attachScreen: 'Attach a screenshot',
+        removeShot: 'Remove',
+        shotLabel: 'Screenshot attached',
+        shotFailed: 'The screenshot could not be taken.',
+        textPlaceholder: 'Tell us what you think…',
+        helpPlaceholder: 'Explain what is blocking you…',
+        micUnavailable: 'The microphone is not available: you can type instead.',
+        sending: 'Sending…',
+        thanks: 'Thank you! Your feedback was sent.',
+        thanksSub: 'The team will read it soon.',
+        helpThanks: 'Thank you! Your request was sent.',
+        helpThanksSub: 'We will get back to you as soon as possible.',
+        failed: 'Sending failed. Your recording is kept.',
+        retry: 'Try again',
+        switchToText: 'Type instead',
+        tooShort: 'Recording too short, try again.',
+        emptyText: 'Write a few words before sending.',
+        track: 'Follow my feedback',
+        brand: 'Powered by Parlo',
+        defaultQuestion: 'A thought or an idea? Tell us out loud.',
+        helpQuestion: 'Describe your problem and we will help you.',
+    },
+    es: {
+        button: 'Dar mi opinión',
+        close: 'Cerrar',
+        chooseFeedback: 'Dar mi opinión',
+        chooseHelp: 'Pedir ayuda',
+        consent: 'Tu voz se graba y se transcribe para ayudar al equipo. Nunca se usa para identificarte.',
+        privacy: 'Privacidad',
+        talk: 'Hablar',
+        write: 'Prefiero escribir',
+        backToVoice: 'Volver a la voz',
+        stop: 'Terminar',
+        play: 'Escuchar',
+        pause: 'Pausa',
+        redo: 'Empezar de nuevo',
+        send: 'Enviar',
+        email: 'Tu email (opcional, para poder responderte)',
+        helpEmail: 'Tu email, para recibir nuestra respuesta',
+        attachScreen: 'Adjuntar una captura',
+        removeShot: 'Quitar',
+        shotLabel: 'Captura adjunta',
+        shotFailed: 'No se pudo hacer la captura.',
+        textPlaceholder: 'Cuéntanos qué piensas…',
+        helpPlaceholder: 'Explica qué te bloquea…',
+        micUnavailable: 'El micrófono no está disponible: puedes escribirnos.',
+        sending: 'Enviando…',
+        thanks: '¡Gracias! Tu opinión se ha enviado.',
+        thanksSub: 'El equipo la leerá muy pronto.',
+        helpThanks: '¡Gracias! Tu solicitud se ha enviado.',
+        helpThanksSub: 'Te responderemos lo antes posible.',
+        failed: 'El envío ha fallado. Tu grabación se ha conservado.',
+        retry: 'Reintentar',
+        switchToText: 'Pasar a escribir',
+        tooShort: 'Grabación demasiado corta, inténtalo de nuevo.',
+        emptyText: 'Escribe unas palabras antes de enviar.',
+        track: 'Seguir mi opinión',
+        brand: 'Con la tecnología de Parlo',
+        defaultQuestion: '¿Un comentario, una idea? Cuéntanoslo en voz alta.',
+        helpQuestion: 'Describe tu problema y te ayudaremos.',
+    },
+    de: {
+        button: 'Feedback geben',
+        close: 'Schließen',
+        chooseFeedback: 'Feedback geben',
+        chooseHelp: 'Hilfe erhalten',
+        consent: 'Deine Stimme wird aufgenommen und transkribiert, um dem Team zu helfen. Sie wird nie verwendet, um dich zu identifizieren.',
+        privacy: 'Datenschutz',
+        talk: 'Sprechen',
+        write: 'Lieber schreiben',
+        backToVoice: 'Zurück zur Sprache',
+        stop: 'Fertig',
+        play: 'Anhören',
+        pause: 'Pause',
+        redo: 'Neu aufnehmen',
+        send: 'Senden',
+        email: 'Deine E-Mail (optional, damit wir antworten können)',
+        helpEmail: 'Deine E-Mail, um unsere Antwort zu erhalten',
+        attachScreen: 'Screenshot anhängen',
+        removeShot: 'Entfernen',
+        shotLabel: 'Screenshot angehängt',
+        shotFailed: 'Der Screenshot konnte nicht erstellt werden.',
+        textPlaceholder: 'Sag uns, was du denkst…',
+        helpPlaceholder: 'Erklär, was dich blockiert…',
+        micUnavailable: 'Das Mikrofon ist nicht verfügbar: Du kannst uns stattdessen schreiben.',
+        sending: 'Wird gesendet…',
+        thanks: 'Danke! Dein Feedback wurde gesendet.',
+        thanksSub: 'Das Team liest es bald.',
+        helpThanks: 'Danke! Deine Anfrage wurde gesendet.',
+        helpThanksSub: 'Wir melden uns so schnell wie möglich.',
+        failed: 'Senden fehlgeschlagen. Deine Aufnahme bleibt erhalten.',
+        retry: 'Erneut versuchen',
+        switchToText: 'Lieber schreiben',
+        tooShort: 'Aufnahme zu kurz, bitte erneut versuchen.',
+        emptyText: 'Schreib ein paar Worte, bevor du sendest.',
+        track: 'Mein Feedback verfolgen',
+        brand: 'Bereitgestellt von Parlo',
+        defaultQuestion: 'Eine Anmerkung, eine Idee? Sag es uns laut.',
+        helpQuestion: 'Beschreib dein Problem, wir helfen dir.',
+    },
+    it: {
+        button: 'Dai il tuo parere',
+        close: 'Chiudi',
+        chooseFeedback: 'Dai il tuo parere',
+        chooseHelp: 'Chiedi aiuto',
+        consent: 'La tua voce viene registrata e trascritta per aiutare il team. Non viene mai usata per identificarti.',
+        privacy: 'Privacy',
+        talk: 'Parla',
+        write: 'Preferisco scrivere',
+        backToVoice: 'Torna alla voce',
+        stop: 'Fine',
+        play: 'Ascolta',
+        pause: 'Pausa',
+        redo: 'Ricomincia',
+        send: 'Invia',
+        email: 'La tua email (facoltativa, per poterti rispondere)',
+        helpEmail: 'La tua email, per ricevere la nostra risposta',
+        attachScreen: 'Allega una schermata',
+        removeShot: 'Rimuovi',
+        shotLabel: 'Schermata allegata',
+        shotFailed: 'Impossibile catturare la schermata.',
+        textPlaceholder: 'Dicci cosa ne pensi…',
+        helpPlaceholder: 'Spiega cosa ti blocca…',
+        micUnavailable: 'Il microfono non è disponibile: puoi scriverci.',
+        sending: 'Invio…',
+        thanks: 'Grazie! Il tuo parere è stato inviato.',
+        thanksSub: 'Il team lo leggerà presto.',
+        helpThanks: 'Grazie! La tua richiesta è stata inviata.',
+        helpThanksSub: 'Ti risponderemo il prima possibile.',
+        failed: 'Invio non riuscito. La tua registrazione è stata conservata.',
+        retry: 'Riprova',
+        switchToText: 'Passa alla scrittura',
+        tooShort: 'Registrazione troppo breve, riprova.',
+        emptyText: 'Scrivi qualche parola prima di inviare.',
+        track: 'Segui il mio parere',
+        brand: 'Realizzato con Parlo',
+        defaultQuestion: 'Un commento, un’idea? Diccelo a voce.',
+        helpQuestion: 'Descrivi il tuo problema, ti aiuteremo.',
+    },
+    pt: {
+        button: 'Dar a minha opinião',
+        close: 'Fechar',
+        chooseFeedback: 'Dar a minha opinião',
+        chooseHelp: 'Pedir ajuda',
+        consent: 'A sua voz é gravada e transcrita para ajudar a equipa. Nunca é usada para o identificar.',
+        privacy: 'Privacidade',
+        talk: 'Falar',
+        write: 'Prefiro escrever',
+        backToVoice: 'Voltar à voz',
+        stop: 'Terminar',
+        play: 'Ouvir',
+        pause: 'Pausa',
+        redo: 'Recomeçar',
+        send: 'Enviar',
+        email: 'O seu email (opcional, para lhe podermos responder)',
+        helpEmail: 'O seu email, para receber a nossa resposta',
+        attachScreen: 'Anexar uma captura',
+        removeShot: 'Remover',
+        shotLabel: 'Captura anexada',
+        shotFailed: 'Não foi possível fazer a captura.',
+        textPlaceholder: 'Diga-nos o que pensa…',
+        helpPlaceholder: 'Explique o que o está a bloquear…',
+        micUnavailable: 'O microfone não está disponível: pode escrever-nos.',
+        sending: 'A enviar…',
+        thanks: 'Obrigado! A sua opinião foi enviada.',
+        thanksSub: 'A equipa vai lê-la em breve.',
+        helpThanks: 'Obrigado! O seu pedido foi enviado.',
+        helpThanksSub: 'Responderemos o mais rapidamente possível.',
+        failed: 'O envio falhou. A sua gravação foi guardada.',
+        retry: 'Tentar novamente',
+        switchToText: 'Passar a escrever',
+        tooShort: 'Gravação demasiado curta, tente novamente.',
+        emptyText: 'Escreva algumas palavras antes de enviar.',
+        track: 'Acompanhar a minha opinião',
+        brand: 'Com tecnologia Parlo',
+        defaultQuestion: 'Um comentário, uma ideia? Diga-nos em voz alta.',
+        helpQuestion: 'Descreva o seu problema e vamos ajudá-lo.',
+    },
+    nl: {
+        button: 'Feedback geven',
+        close: 'Sluiten',
+        chooseFeedback: 'Feedback geven',
+        chooseHelp: 'Hulp vragen',
+        consent: 'Je stem wordt opgenomen en uitgeschreven om het team te helpen. Hij wordt nooit gebruikt om je te identificeren.',
+        privacy: 'Privacy',
+        talk: 'Spreken',
+        write: 'Ik typ liever',
+        backToVoice: 'Terug naar spraak',
+        stop: 'Klaar',
+        play: 'Beluisteren',
+        pause: 'Pauze',
+        redo: 'Opnieuw',
+        send: 'Versturen',
+        email: 'Je e-mail (optioneel, zodat we kunnen antwoorden)',
+        helpEmail: 'Je e-mail, om ons antwoord te ontvangen',
+        attachScreen: 'Screenshot toevoegen',
+        removeShot: 'Verwijderen',
+        shotLabel: 'Screenshot toegevoegd',
+        shotFailed: 'De screenshot kon niet worden gemaakt.',
+        textPlaceholder: 'Vertel ons wat je denkt…',
+        helpPlaceholder: 'Leg uit wat je tegenhoudt…',
+        micUnavailable: 'De microfoon is niet beschikbaar: je kunt ons ook schrijven.',
+        sending: 'Versturen…',
+        thanks: 'Bedankt! Je feedback is verstuurd.',
+        thanksSub: 'Het team leest hem snel.',
+        helpThanks: 'Bedankt! Je vraag is verstuurd.',
+        helpThanksSub: 'We antwoorden zo snel mogelijk.',
+        failed: 'Versturen mislukt. Je opname is bewaard.',
+        retry: 'Opnieuw proberen',
+        switchToText: 'Liever typen',
+        tooShort: 'Opname te kort, probeer het opnieuw.',
+        emptyText: 'Schrijf een paar woorden voordat je verstuurt.',
+        track: 'Mijn feedback volgen',
+        brand: 'Mogelijk gemaakt door Parlo',
+        defaultQuestion: 'Een opmerking, een idee? Zeg het ons hardop.',
+        helpQuestion: 'Beschrijf je probleem, we helpen je.',
+    },
+};
+export function pickStrings(forced, remote) {
+    let device = 'en';
+    try {
+        device = Intl.DateTimeFormat().resolvedOptions().locale || 'en';
+    }
+    catch {
+        device = 'en';
+    }
+    const wanted = forced || (remote && remote !== 'auto' ? remote : device);
+    const code = wanted.toLowerCase().slice(0, 2);
+    return code in STRINGS ? STRINGS[code] : STRINGS.en;
+}

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { ParloProvider, useParlo, type ParloProviderProps } from './ParloProvider';
+export type { ParloApi, ParloContext, ParloIntent, ParloOpenOptions, ParloRemoteConfig, ParloUser } from './types';

package/lib/index.js

@@ -0,0 +1 @@
+export { ParloProvider, useParlo } from './ParloProvider';

package/lib/types.d.ts

@@ -0,0 +1,31 @@
+export type ParloUser = {
+    id: string;
+    email?: string;
+    name?: string;
+    hash?: string;
+};
+export type ParloIntent = 'feedback' | 'support';
+export type ParloContext = Record<string, string | number | boolean>;
+export type ParloOpenOptions = {
+    intent?: ParloIntent;
+};
+export type ParloRemoteConfig = {
+    color: string;
+    question: string;
+    questionIsDefault: boolean;
+    locale: string;
+    maxSeconds: number;
+    branding: boolean;
+    screenshots: boolean;
+    support: boolean;
+};
+export type ParloApi = {
+    open: (options?: ParloOpenOptions) => void;
+    close: () => void;
+    identify: (user: ParloUser | null) => void;
+    logout: () => void;
+    setContext: (context: ParloContext | null) => void;
+    setVersion: (version: string | null) => void;
+    setScreen: (screen: string | null) => void;
+    ready: boolean;
+};

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,53 @@
 {
   "name": "@sayparlo/react-native",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Voice feedback and help requests for Expo and React Native apps, powered by Parlo.",
+  "main": "lib/index.js",
+  "module": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "lib/index.js",
+  "files": [
+    "lib",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "rm -rf lib && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "keywords": [
+    "feedback",
+    "voice",
+    "expo",
+    "react-native",
+    "support",
+    "parlo"
+  ],
+  "homepage": "https://sayparlo.com/docs/react-native",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nobscorp/parlo-react-native.git"
+  },
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "expo-application": "*",
+    "expo-audio": ">=0.4.0",
+    "expo-device": "*",
+    "react": ">=18.2.0",
+    "react-native": ">=0.76.0"
+  },
+  "devDependencies": {
+    "@types/react": "^19.3.0",
+    "expo": "^58.0.25",
+    "expo-application": "^58.1.2",
+    "expo-audio": "^58.0.12",
+    "expo-device": "^58.0.5",
+    "react": "^19.3.1",
+    "react-native": "^0.88.1",
+    "typescript": "^7.0.2"
+  }
+}