@qafka/react-native 2.0.0

package/dist/hooks/useVoiceChat.js

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useVoiceChat = useVoiceChat;
+const react_1 = require("react");
+const react_native_1 = require("react-native");
+const RealtimeService_1 = require("../services/RealtimeService");
+const QafkaAudio_1 = require("../native/QafkaAudio");
+function useVoiceChat({ apiUrl, apiKey, userContext, contextDescription, onToolSuggested, toolRenderMode = 'upsert', getSessionToken, endUserId, endUserData, }) {
+    const [state, setState] = (0, react_1.useState)('idle');
+    const [transcript, setTranscript] = (0, react_1.useState)('');
+    const [userTranscript, setUserTranscript] = (0, react_1.useState)('');
+    const [transcriptHistory, setTranscriptHistory] = (0, react_1.useState)([]);
+    const [amplitude, setAmplitude] = (0, react_1.useState)(0);
+    const [toolStatus, setToolStatus] = (0, react_1.useState)(null);
+    const [renderedTools, setRenderedTools] = (0, react_1.useState)([]);
+    const [transcriptOverrideForTurn, setTranscriptOverrideForTurn] = (0, react_1.useState)(false);
+    const serviceRef = (0, react_1.useRef)(null);
+    // Snapshot of the live AI transcript so `response.done` can push the
+    // finished text into history without depending on stale closure state.
+    const transcriptRef = (0, react_1.useRef)('');
+    const amplitudeUnsubRef = (0, react_1.useRef)(null);
+    const onToolSuggestedRef = (0, react_1.useRef)(onToolSuggested);
+    (0, react_1.useEffect)(() => {
+        onToolSuggestedRef.current = onToolSuggested;
+    }, [onToolSuggested]);
+    // handleEvent is wrapped in useCallback([]) so we read the live value
+    // through a ref to avoid stale closures.
+    const toolRenderModeRef = (0, react_1.useRef)(toolRenderMode);
+    (0, react_1.useEffect)(() => {
+        toolRenderModeRef.current = toolRenderMode;
+    }, [toolRenderMode]);
+    // Two-layer mute orchestration. The hook itself mutes/unmutes the mic
+    // around tool flows ("system" layer); the user can also toggle mute from
+    // the UI ("user" layer). The effective mute is `user || system`, and a
+    // system unmute MUST NOT override an active user mute — otherwise the
+    // user's mute would silently lift the moment a tool finishes.
+    const userMutedRef = (0, react_1.useRef)(false);
+    const systemMutedRef = (0, react_1.useRef)(false);
+    const [isMuted, setIsMuted] = (0, react_1.useState)(false);
+    const systemMute = (0, react_1.useCallback)(() => {
+        systemMutedRef.current = true;
+        serviceRef.current?.muteMic();
+    }, []);
+    const systemUnmute = (0, react_1.useCallback)(() => {
+        systemMutedRef.current = false;
+        if (userMutedRef.current)
+            return;
+        serviceRef.current?.unmuteMic();
+    }, []);
+    const mute = (0, react_1.useCallback)(() => {
+        if (userMutedRef.current)
+            return;
+        userMutedRef.current = true;
+        setIsMuted(true);
+        serviceRef.current?.muteMic();
+    }, []);
+    const unmute = (0, react_1.useCallback)(() => {
+        if (!userMutedRef.current)
+            return;
+        userMutedRef.current = false;
+        setIsMuted(false);
+        // Only lift the mic if no system mute is active.
+        if (!systemMutedRef.current) {
+            serviceRef.current?.unmuteMic();
+        }
+    }, []);
+    const toggleMute = (0, react_1.useCallback)(() => {
+        if (userMutedRef.current)
+            unmute();
+        else
+            mute();
+    }, [mute, unmute]);
+    const handleEvent = (0, react_1.useCallback)(async (event) => {
+        switch (event.type) {
+            case 'session.ready':
+                setState('listening');
+                return;
+            case 'conversation.item.input_audio_transcription.completed':
+                setUserTranscript(event.transcript);
+                // Append the completed user turn to history for chat-style transcript views.
+                if (event.transcript && event.transcript.trim().length > 0) {
+                    setTranscriptHistory((h) => [
+                        ...h,
+                        { id: `u_${Date.now()}_${h.length}`, role: 'user', text: event.transcript },
+                    ]);
+                }
+                setState('thinking');
+                return;
+            case 'response.text.delta':
+                setState('speaking');
+                setTranscript((prev) => {
+                    const next = prev + event.delta;
+                    transcriptRef.current = next;
+                    return next;
+                });
+                return;
+            case 'response.done': {
+                // Snapshot the live AI text BEFORE clearing so we can push it to history.
+                const finalAi = transcriptRef.current;
+                if (finalAi && finalAi.trim().length > 0) {
+                    setTranscriptHistory((h) => [
+                        ...h,
+                        { id: `a_${Date.now()}_${h.length}`, role: 'assistant', text: finalAi },
+                    ]);
+                }
+                transcriptRef.current = '';
+                setTranscript('');
+                setState('listening');
+                return;
+            }
+            case 'session.closed':
+                setState('idle');
+                return;
+            case 'error':
+                setState('idle');
+                return;
+            case 'tool_status':
+                setToolStatus({
+                    toolCallId: event.toolCallId,
+                    toolKey: event.toolKey,
+                    loadingMessage: event.loadingMessage,
+                });
+                return;
+            case 'tool_suggested': {
+                // Built-in qafka_display: handled locally, never delegated to consumer.
+                // Backend already pushed a synthetic {result:'ok'} to Gemini for this
+                // toolCallId, so we MUST NOT call sendToolResult here — doing so would
+                // either be silently dropped (no pending entry) or, worse, race with
+                // the backend's response and confuse the upstream session.
+                // Also defensively unmute the mic: although our intercept never mutes,
+                // unmuteMic is idempotent and protects against any prior mute that
+                // wasn't cleared (e.g. a stale tool flow before this turn).
+                const firstTool = event.tools?.[0];
+                const firstName = firstTool?.key ?? firstTool?.name;
+                if (firstName === 'qafka_display') {
+                    const args = firstTool?.parameters ?? {};
+                    const mode = args?.mode;
+                    if (mode === 'chip') {
+                        const rawItems = Array.isArray(args?.items) ? args.items : [];
+                        const items = rawItems
+                            .filter((it) => it &&
+                            typeof it.label === 'string' &&
+                            typeof it.value === 'string' &&
+                            it.value.length > 0)
+                            .slice(0, 5)
+                            .map((it) => ({
+                            label: String(it.label),
+                            value: String(it.value),
+                            copyable: it.copyable !== false,
+                        }));
+                        if (items.length > 0) {
+                            const entry = {
+                                kind: 'display',
+                                toolCallId: event.toolCallId,
+                                items,
+                            };
+                            setRenderedTools((prev) => [
+                                ...prev.filter((rt) => rt.toolCallId !== event.toolCallId),
+                                entry,
+                            ]);
+                        }
+                        setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                        systemUnmute();
+                        return;
+                    }
+                    if (mode === 'transcript') {
+                        setTranscriptOverrideForTurn(true);
+                        setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                        systemUnmute();
+                        return;
+                    }
+                    // Unknown mode — render nothing. Backend already closed Gemini's
+                    // turn with {result:'ok'}; no SDK action besides clearing UI state.
+                    setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                    systemUnmute();
+                    return;
+                }
+                // A non-display tool means the AI is about to surface UI (card,
+                // list, etc.). Sticky transcript override would suppress that, so
+                // any incoming card tool auto-exits transcript mode.
+                setTranscriptOverrideForTurn(false);
+                const handler = onToolSuggestedRef.current;
+                const fallbackToolName = event.tools?.[0]?.key ?? event.tools?.[0]?.name ?? 'unknown';
+                if (!handler) {
+                    // No consumer handler registered. Explicitly skip on the server so
+                    // the realtime turn doesn't sit in the 30s tool timeout waiting for
+                    // a tool_result that will never arrive — Gemini falls back to a
+                    // text answer immediately instead of leaving the user in 30s of
+                    // "thinking" silence.
+                    // ok:true + structured note (not ok:false) because the server drops
+                    // `output` on ok:false and only forwards the error string to Gemini —
+                    // which leaves the model to invent a recovery (apology, hallucinated
+                    // answer, retry loop). With ok:true the `note` reaches Gemini as the
+                    // tool result and steers it toward a graceful, grounded response.
+                    serviceRef.current?.sendToolResult({
+                        toolCallId: event.toolCallId,
+                        toolName: fallbackToolName,
+                        output: {
+                            status: 'client_unavailable',
+                            note: 'This action is not available in the client app right now. Do not invent details. Briefly apologize in the user\'s language, then either answer from the knowledge base if relevant or offer to help with a different request.',
+                        },
+                        ok: true,
+                    });
+                    setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                    return;
+                }
+                let addResponseCalled = false;
+                let responded = false;
+                // Mute (not pause) so the AI's turn-2 audio playback keeps working —
+                // iOS AVAudioEngine unifies capture and playback, so a full pauseMic
+                // would also stop playAudioChunk during the AI's response.
+                systemMute();
+                const addResponse = async (data, tool, mode = 'both') => {
+                    addResponseCalled = true;
+                    const toolKey = tool?.key ?? tool?.name ?? '';
+                    // Only mark "responded" when we actually commit the tool flow.
+                    // A "ui"-only call leaves the tool open — the consumer must follow
+                    // up with a final "data" or "both" call to close it.
+                    const updatesUI = mode === 'ui' || mode === 'both';
+                    const commits = mode === 'data' || mode === 'both';
+                    if (commits) {
+                        responded = true;
+                    }
+                    if (updatesUI) {
+                        // Apply toolRenderMode:
+                        // "replace" → only the latest tool result is kept on screen
+                        // "upsert" → same toolKey replaces, different keys coexist
+                        const entry = {
+                            toolCallId: event.toolCallId,
+                            toolKey,
+                            data,
+                            tool,
+                        };
+                        if (toolRenderModeRef.current === 'replace') {
+                            setRenderedTools(() => [entry]);
+                        }
+                        else {
+                            setRenderedTools((prev) => {
+                                const next = prev.filter((rt) => rt.toolKey !== toolKey);
+                                next.push(entry);
+                                return next;
+                            });
+                        }
+                    }
+                    if (commits) {
+                        if (tool?.executionMode === 'custom-with-ai') {
+                            // Send data to backend → forwarded as toolResponse to the AI →
+                            // turn 2 audio. Pill stays visible until backend sends tool_done
+                            // (cleared in tool_done case). Keep mic muted during AI's
+                            // response — tool_done will unmute when AI is done.
+                            serviceRef.current?.sendToolResult({
+                                toolCallId: event.toolCallId,
+                                toolName: toolKey,
+                                output: data,
+                                ok: true,
+                            });
+                        }
+                        else {
+                            // custom (or unspecified): immediate local resolution (UC1 path).
+                            setToolStatus((s) => s?.toolCallId === event.toolCallId ? null : s);
+                            systemUnmute();
+                        }
+                    }
+                    return {
+                        ok: true,
+                        toolName: toolKey,
+                        toolOutput: data,
+                    };
+                };
+                try {
+                    await handler(event.tools, addResponse);
+                }
+                catch (err) {
+                    if (__DEV__) {
+                        console.warn('[Qafka] onToolSuggested threw:', err);
+                    }
+                }
+                if (!addResponseCalled) {
+                    // Handler returned (or threw) without invoking addResponse at all —
+                    // e.g. it bailed because required context refs weren't wired up.
+                    // Send an explicit skip so the server doesn't sit in its 30s tool
+                    // timeout; Gemini will produce a fallback response immediately.
+                    // ok:true + structured note (not ok:false) because the server drops
+                    // `output` on ok:false and only forwards the error string to Gemini —
+                    // which leaves the model to invent a recovery (apology, hallucinated
+                    // answer, retry loop). With ok:true the `note` reaches Gemini as the
+                    // tool result and steers it toward a graceful, grounded response.
+                    serviceRef.current?.sendToolResult({
+                        toolCallId: event.toolCallId,
+                        toolName: fallbackToolName,
+                        output: {
+                            status: 'client_unavailable',
+                            note: 'This action is not available in the client app right now. Do not invent details. Briefly apologize in the user\'s language, then either answer from the knowledge base if relevant or offer to help with a different request.',
+                        },
+                        ok: true,
+                    });
+                    setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                    systemUnmute();
+                }
+                else if (!responded) {
+                    // addResponse was called but only in 'ui' mode — UI rendered, no
+                    // commit yet. The consumer is expected to commit later via another
+                    // addResponse('data' | 'both') call. Clear pill and unmute mic so
+                    // user isn't blocked in the meantime; the server 30s timeout remains
+                    // the safety net if the consumer never commits.
+                    setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                    systemUnmute();
+                }
+                return;
+            }
+            case 'tool_done':
+                // Backend signaled the tool flow is complete (either the AI consumed the result or
+                // synthetic delegated response sent (custom). Either way: clear pill and
+                // unmute mic so user can speak again. unmuteMic is idempotent — safe to
+                // call even if already unmuted (e.g. UC1 unmuted in addResponse).
+                setToolStatus((s) => (s?.toolCallId === event.toolCallId ? null : s));
+                systemUnmute();
+                return;
+        }
+    }, []);
+    const connect = (0, react_1.useCallback)(async () => {
+        if (serviceRef.current?.isConnected)
+            return;
+        setState('connecting');
+        const service = new RealtimeService_1.RealtimeService(apiUrl, apiKey);
+        if (getSessionToken)
+            service.setSessionTokenGetter(getSessionToken);
+        serviceRef.current = service;
+        try {
+            await service.connect(handleEvent, {
+                userContext,
+                contextDescription,
+                endUserId,
+                endUserData,
+            });
+            // Throttle amplitude to ~20fps. Native emits per audio chunk (can exceed
+            // 100Hz during playback); unbounded setState floods the React commit
+            // queue and can cascade into "Maximum update depth exceeded" if
+            // consumer-tree components animate or re-derive state on amplitude.
+            // Use OR semantics so we always skip when too recent OR change is
+            // imperceptible — earlier AND logic let amplitude through whenever it
+            // changed by >0.02, defeating the throttle during loud audio.
+            let lastEmitMs = 0;
+            let lastLevel = 0;
+            amplitudeUnsubRef.current = QafkaAudio_1.QafkaAudio.onAmplitude(({ level }) => {
+                const now = Date.now();
+                if (now - lastEmitMs < 50)
+                    return;
+                if (Math.abs(level - lastLevel) < 0.02)
+                    return;
+                lastEmitMs = now;
+                lastLevel = level;
+                setAmplitude(level);
+            });
+        }
+        catch {
+            setState('idle');
+            serviceRef.current = null;
+        }
+    }, [apiUrl, apiKey, handleEvent, userContext, contextDescription, getSessionToken, endUserId, endUserData]);
+    const disconnect = (0, react_1.useCallback)(async () => {
+        amplitudeUnsubRef.current?.();
+        amplitudeUnsubRef.current = null;
+        await serviceRef.current?.disconnect();
+        serviceRef.current = null;
+        setState('idle');
+        setTranscript('');
+        setUserTranscript('');
+        setTranscriptHistory([]);
+        transcriptRef.current = '';
+        setAmplitude(0);
+        // Reset both mute layers so the next session starts clean.
+        userMutedRef.current = false;
+        systemMutedRef.current = false;
+        setIsMuted(false);
+    }, []);
+    const pauseMic = (0, react_1.useCallback)(async () => {
+        await serviceRef.current?.pauseMic();
+    }, []);
+    const resumeMic = (0, react_1.useCallback)(async () => {
+        await serviceRef.current?.resumeMic();
+    }, []);
+    // Disconnect on app background
+    (0, react_1.useEffect)(() => {
+        const handleAppState = (nextState) => {
+            if (nextState !== 'active' && serviceRef.current?.isConnected) {
+                disconnect();
+            }
+        };
+        const sub = react_native_1.AppState.addEventListener('change', handleAppState);
+        return () => sub.remove();
+    }, [disconnect]);
+    // Cleanup on unmount
+    (0, react_1.useEffect)(() => {
+        return () => {
+            amplitudeUnsubRef.current?.();
+            serviceRef.current?.disconnect();
+        };
+    }, []);
+    return {
+        state,
+        transcript,
+        userTranscript,
+        transcriptHistory,
+        amplitude,
+        connect,
+        disconnect,
+        pauseMic,
+        resumeMic,
+        isConnected: serviceRef.current?.isConnected ?? false,
+        toolStatus,
+        renderedTools,
+        transcriptOverrideForTurn,
+        clearRenderedTools: () => setRenderedTools([]),
+        setToolStatusManually: (status) => {
+            if (status) {
+                setToolStatus({
+                    toolCallId: `manual_${Date.now()}`,
+                    toolKey: status.toolKey,
+                    loadingMessage: status.loadingMessage,
+                });
+                // Mute (don't pause) so AI playback works if the developer's async work
+                // overlaps with an in-flight AI response.
+                systemMute();
+            }
+            else {
+                setToolStatus(null);
+                systemUnmute();
+            }
+        },
+        isMuted,
+        mute,
+        unmute,
+        toggleMute,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/// <reference path="../qafka.config.d.ts" />
+/**
+ * QafkaSDK for React Native
+ * AI-powered conversational interface with navigation intelligence
+ */
+export { QafkaSDK, getSDK } from './QafkaSDK';
+export declare const getVersion: () => string;
+export declare const isVersionAtLeast: (minVersion: string) => boolean;
+export * from './components';
+export * from './themes';
+export * from './types';
+export * from './constants';
+export * from './cards';

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * QafkaSDK for React Native
+ * AI-powered conversational interface with navigation intelligence
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVersionAtLeast = exports.getVersion = exports.getSDK = exports.QafkaSDK = void 0;
+// Main SDK export
+var QafkaSDK_1 = require("./QafkaSDK");
+Object.defineProperty(exports, "QafkaSDK", { enumerable: true, get: function () { return QafkaSDK_1.QafkaSDK; } });
+Object.defineProperty(exports, "getSDK", { enumerable: true, get: function () { return QafkaSDK_1.getSDK; } });
+const package_json_1 = require("../package.json");
+const getVersion = () => package_json_1.version;
+exports.getVersion = getVersion;
+const compare = (targetVersion) => {
+    // Strip build metadata (+hash) and pre-release tags (-beta) from versions
+    // e.g. "0.1.7+abc1234" -> "0.1.7"
+    const cleanCurrentVersion = package_json_1.version.split('+')[0].split('-')[0];
+    const cleanTargetVersion = targetVersion.split('+')[0].split('-')[0];
+    const currentParts = cleanCurrentVersion.split('.').map(Number);
+    const targetParts = cleanTargetVersion.split('.').map(Number);
+    for (let i = 0; i < Math.max(currentParts.length, targetParts.length); i++) {
+        const v1 = currentParts[i] || 0;
+        const v2 = targetParts[i] || 0;
+        if (v1 > v2)
+            return 1;
+        if (v1 < v2)
+            return -1;
+    }
+    return 0;
+};
+const isVersionAtLeast = (minVersion) => {
+    return compare(minVersion) >= 0;
+};
+exports.isVersionAtLeast = isVersionAtLeast;
+// UI Components
+__exportStar(require("./components"), exports);
+// Theme System
+__exportStar(require("./themes"), exports);
+// Export types
+__exportStar(require("./types"), exports);
+// Export constants
+__exportStar(require("./constants"), exports);
+// Card Template
+__exportStar(require("./cards"), exports);

package/dist/native/QafkaAttestation.d.ts

@@ -0,0 +1,23 @@
+import { Platform } from 'react-native';
+export interface QafkaDeviceInfo {
+    bundleId: string;
+    appVersion: string;
+    deviceModel: string;
+}
+/**
+ * Device info exposed as sync constants from the native QafkaAttestation
+ * module. Read once at boot — the values are static for the app's lifetime.
+ *
+ * Returns empty strings (not null) when the native module is missing so
+ * downstream code does not need null guards. Caller should treat empty
+ * strings as "unknown".
+ */
+export declare function getDeviceInfo(): QafkaDeviceInfo;
+export declare function isAttestationAvailable(): boolean;
+export declare function isSupported(): Promise<boolean>;
+export declare function generateKey(): Promise<string>;
+export declare function attestKey(keyId: string, challengeBase64: string): Promise<string>;
+export declare function generateAssertion(keyId: string, clientDataBase64: string): Promise<string>;
+export declare function generateKeyPair(alias: string, challengeBase64: string): Promise<void>;
+export declare function getAttestationCertChain(alias: string): Promise<string[]>;
+export { Platform };

package/dist/native/QafkaAttestation.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Platform = void 0;
+exports.getDeviceInfo = getDeviceInfo;
+exports.isAttestationAvailable = isAttestationAvailable;
+exports.isSupported = isSupported;
+exports.generateKey = generateKey;
+exports.attestKey = attestKey;
+exports.generateAssertion = generateAssertion;
+exports.generateKeyPair = generateKeyPair;
+exports.getAttestationCertChain = getAttestationCertChain;
+const react_native_1 = require("react-native");
+Object.defineProperty(exports, "Platform", { enumerable: true, get: function () { return react_native_1.Platform; } });
+const NativeAttestation = react_native_1.NativeModules.QafkaAttestation ?? null;
+/**
+ * Device info exposed as sync constants from the native QafkaAttestation
+ * module. Read once at boot — the values are static for the app's lifetime.
+ *
+ * Returns empty strings (not null) when the native module is missing so
+ * downstream code does not need null guards. Caller should treat empty
+ * strings as "unknown".
+ */
+function getDeviceInfo() {
+    const mod = react_native_1.NativeModules.QafkaAttestation;
+    return {
+        bundleId: mod?.bundleId ?? '',
+        appVersion: mod?.appVersion ?? '',
+        deviceModel: mod?.deviceModel ?? '',
+    };
+}
+function isAttestationAvailable() {
+    return NativeAttestation !== null;
+}
+async function isSupported() {
+    if (!NativeAttestation)
+        return false;
+    try {
+        return await NativeAttestation.isSupported();
+    }
+    catch {
+        return false;
+    }
+}
+// iOS methods
+async function generateKey() {
+    if (!NativeAttestation?.generateKey)
+        throw new Error('iOS only');
+    return NativeAttestation.generateKey();
+}
+async function attestKey(keyId, challengeBase64) {
+    if (!NativeAttestation?.attestKey)
+        throw new Error('iOS only');
+    return NativeAttestation.attestKey(keyId, challengeBase64);
+}
+async function generateAssertion(keyId, clientDataBase64) {
+    if (!NativeAttestation?.generateAssertion)
+        throw new Error('iOS only');
+    return NativeAttestation.generateAssertion(keyId, clientDataBase64);
+}
+// Android methods
+async function generateKeyPair(alias, challengeBase64) {
+    if (!NativeAttestation?.generateKeyPair)
+        throw new Error('Android only');
+    return NativeAttestation.generateKeyPair(alias, challengeBase64);
+}
+async function getAttestationCertChain(alias) {
+    if (!NativeAttestation?.getAttestationCertChain)
+        throw new Error('Android only');
+    return NativeAttestation.getAttestationCertChain(alias);
+}

package/dist/native/QafkaAudio.d.ts

@@ -0,0 +1,14 @@
+export declare const QafkaAudio: {
+    startCapture: () => Promise<boolean>;
+    stopCapture: () => Promise<boolean>;
+    playAudioChunk: (base64Data: string) => Promise<boolean>;
+    stopPlayback: () => Promise<boolean>;
+    onAudioData: (callback: (data: {
+        audio: string;
+    }) => void) => () => void | undefined;
+    onAmplitude: (callback: (data: {
+        level: number;
+        source: "mic" | "speaker";
+    }) => void) => () => void | undefined;
+    isAvailable: () => boolean;
+};

package/dist/native/QafkaAudio.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QafkaAudio = void 0;
+const react_native_1 = require("react-native");
+const { QafkaAudio: NativeQafkaAudio } = react_native_1.NativeModules;
+const emitter = NativeQafkaAudio ? new react_native_1.NativeEventEmitter(NativeQafkaAudio) : null;
+const MISSING_MODULE_MESSAGE = `QafkaAudio native module is not linked. ` +
+    `The JS bundle was updated but the native binary was not rebuilt. ` +
+    (react_native_1.Platform.OS === 'ios'
+        ? `Run \`cd ios && pod install\` then rebuild the app (\`yarn ios\` or from Xcode).`
+        : `Rebuild the app (\`yarn android\` or \`cd android && ./gradlew clean && ./gradlew assembleDebug\`).`);
+const requireModule = () => {
+    if (!NativeQafkaAudio)
+        throw new Error(MISSING_MODULE_MESSAGE);
+    return NativeQafkaAudio;
+};
+exports.QafkaAudio = {
+    startCapture: () => requireModule().startCapture(),
+    stopCapture: () => requireModule().stopCapture(),
+    playAudioChunk: (base64Data) => requireModule().playAudioChunk(base64Data),
+    stopPlayback: () => requireModule().stopPlayback(),
+    onAudioData: (callback) => {
+        const subscription = emitter?.addListener('onAudioData', callback);
+        return () => subscription?.remove();
+    },
+    onAmplitude: (callback) => {
+        const subscription = emitter?.addListener('onAmplitude', callback);
+        return () => subscription?.remove();
+    },
+    isAvailable: () => NativeQafkaAudio != null,
+};

package/dist/native/QafkaClipboard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Native clipboard module — writes a string to the system clipboard.
+ * iOS: UIPasteboard.general. Android: ClipboardManager (primary clip).
+ *
+ * Zero peer dependencies; ships with the Qafka native package.
+ */
+export interface QafkaClipboardNative {
+    setString(value: string): Promise<void>;
+}
+export declare function isClipboardAvailable(): boolean;
+export declare function setString(value: string): Promise<void>;