kasunk99-livestream-core 0.1.0

package/README.md

@@ -0,0 +1,48 @@
+# @livestream/core
+
+Reusable livestream viewer (and later host) module for React Native / Expo. Talks to a mediasoup + Socket.IO livestream server.
+
+## Peer dependencies
+
+Install in the host app:
+
+- `react`, `react-native`
+- `react-native-webrtc` (required for video; use a dev build, not Expo Go)
+- `mediasoup-client`
+- `socket.io-client`
+
+## Setup
+
+1. Configure before using any component or hook:
+
+```ts
+import { setLivestreamConfig } from '@livestream/core';
+
+setLivestreamConfig({
+  serverHttpUrl: 'http://localhost:3000', // or your server URL
+  getDisplayName: () => 'Viewer', // optional, for chat/room display
+});
+```
+
+2. Use the feed or hooks:
+
+```tsx
+import { LiveStreamFeed } from '@livestream/core';
+
+<LiveStreamFeed />
+```
+
+Or use `useLiveStreams()` and `useViewerSocket(roomId)` for custom UIs.
+
+## Exports
+
+- **Config:** `setLivestreamConfig`, `getBaseUrl`, `getSignalingWsUrl`, `getDisplayName`
+- **Services:** `fetchActiveStreams`, `ensureMediasoupGlobals`
+- **Hooks:** `useViewerSocket`, `useLiveStreams`
+- **Components:** `LiveStreamFeed`, `LiveStreamViewerItem`
+- **Types:** `LiveStreamInfo`, `ProducerInfo`, `JoinRoomResult`, `RoomState`
+
+## Server contract
+
+- **HTTP:** `GET {serverHttpUrl}/api/live-streams` → `{ streams: { roomId, viewerCount, producerCount }[] }`
+- **WebSocket:** Socket.IO at same origin (ws/https). Events: `join-room`, `create-webrtc-transport`, `connect-transport`, `produce`, `consume`, `get-producers`, `new-producer`, `room-updated`, etc.

package/dist/components/LiveStreamFeed.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+/**
+ * TikTok-style vertical feed: one stream per full-screen item.
+ * When the user scrolls to a new item, that item becomes active and joins the stream.
+ */
+export declare function LiveStreamFeed(): React.ReactElement;
+//# sourceMappingURL=LiveStreamFeed.d.ts.map

package/dist/components/LiveStreamFeed.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveStreamFeed.d.ts","sourceRoot":"","sources":["../../src/components/LiveStreamFeed.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAwC,MAAM,OAAO,CAAC;AAoB7D;;;GAGG;AACH,wBAAgB,cAAc,IAAI,KAAK,CAAC,YAAY,CAkHnD"}

package/dist/components/LiveStreamFeed.js

@@ -0,0 +1,84 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useRef, useState } from 'react';
+import { Dimensions, FlatList, RefreshControl, ScrollView, StyleSheet, Text, View, } from 'react-native';
+import { LiveStreamViewerItem } from './LiveStreamViewerItem';
+import { useLiveStreams } from '../hooks/useLiveStreams';
+const { height: SCREEN_HEIGHT } = Dimensions.get('window');
+// Adjust for top header + bottom tab bar so each item fits without extra scroll.
+const VIEWPORT_HEIGHT = SCREEN_HEIGHT - 120;
+/**
+ * TikTok-style vertical feed: one stream per full-screen item.
+ * When the user scrolls to a new item, that item becomes active and joins the stream.
+ */
+export function LiveStreamFeed() {
+    const { streams, loading, error, refetch } = useLiveStreams();
+    const [activeIndex, setActiveIndex] = useState(0);
+    const [refreshing, setRefreshing] = useState(false);
+    const onRefresh = useCallback(async () => {
+        setRefreshing(true);
+        await refetch();
+        setRefreshing(false);
+    }, [refetch]);
+    const viewabilityConfig = useRef({
+        itemVisiblePercentThreshold: 60,
+        minimumViewTime: 100,
+    }).current;
+    const onViewableItemsChanged = useRef(({ viewableItems }) => {
+        const first = viewableItems[0];
+        if (first?.index != null) {
+            setActiveIndex(first.index);
+        }
+    }).current;
+    const onMomentumScrollEnd = useCallback((e) => {
+        const offsetY = e.nativeEvent.contentOffset.y;
+        const index = Math.round(offsetY / VIEWPORT_HEIGHT);
+        const clamped = Math.max(0, Math.min(index, streams.length - 1));
+        setActiveIndex(clamped);
+    }, [streams.length]);
+    const renderItem = useCallback(({ item, index }) => (_jsx(View, { style: styles.item, children: _jsx(LiveStreamViewerItem, { stream: item, isActive: index === activeIndex, index: index }) })), [activeIndex]);
+    const keyExtractor = useCallback((item) => item.roomId, []);
+    const getItemLayout = useCallback((_, index) => ({
+        length: VIEWPORT_HEIGHT,
+        offset: VIEWPORT_HEIGHT * index,
+        index,
+    }), []);
+    if (loading && streams.length === 0) {
+        return (_jsx(View, { style: styles.center, children: _jsx(Text, { style: styles.message, children: "Loading streams..." }) }));
+    }
+    if (error && streams.length === 0) {
+        return (_jsxs(ScrollView, { contentContainerStyle: styles.center, refreshControl: _jsx(RefreshControl, { refreshing: refreshing, onRefresh: onRefresh, tintColor: "#e5e5e5" }), children: [_jsx(Text, { style: styles.error, children: error }), _jsx(Text, { style: styles.hint, children: "Check server URL and pull down to retry." })] }));
+    }
+    if (streams.length === 0) {
+        return (_jsxs(ScrollView, { contentContainerStyle: styles.center, refreshControl: _jsx(RefreshControl, { refreshing: refreshing, onRefresh: onRefresh, tintColor: "#e5e5e5" }), children: [_jsx(Text, { style: styles.message, children: "No live streams right now" }), _jsx(Text, { style: styles.hint, children: "Go live or pull down to refresh." })] }));
+    }
+    return (_jsx(FlatList, { data: streams, renderItem: renderItem, keyExtractor: keyExtractor, getItemLayout: getItemLayout, pagingEnabled: true, nestedScrollEnabled: true, showsVerticalScrollIndicator: false, decelerationRate: "fast", snapToInterval: VIEWPORT_HEIGHT, snapToAlignment: "start", onViewableItemsChanged: onViewableItemsChanged, viewabilityConfig: viewabilityConfig, onMomentumScrollEnd: onMomentumScrollEnd, initialNumToRender: 2, maxToRenderPerBatch: 2, windowSize: 3, refreshControl: _jsx(RefreshControl, { refreshing: refreshing, onRefresh: onRefresh, tintColor: "#e5e5e5" }) }));
+}
+const styles = StyleSheet.create({
+    center: {
+        flex: 1,
+        justifyContent: 'center',
+        alignItems: 'center',
+        backgroundColor: '#0a0a0a',
+        padding: 24,
+    },
+    item: {
+        height: VIEWPORT_HEIGHT,
+        width: '100%',
+    },
+    message: {
+        color: '#e5e5e5',
+        fontSize: 16,
+        textAlign: 'center',
+    },
+    error: {
+        color: '#ef4444',
+        fontSize: 14,
+        textAlign: 'center',
+        marginBottom: 8,
+    },
+    hint: {
+        color: '#737373',
+        fontSize: 12,
+        textAlign: 'center',
+    },
+});

package/dist/components/LiveStreamViewerItem.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { LiveStreamInfo } from '../types';
+type LiveStreamViewerItemProps = {
+    stream: LiveStreamInfo;
+    isActive: boolean;
+    index: number;
+};
+/**
+ * Single full-screen viewer cell. When isActive, joins the stream room and consumes video/audio.
+ */
+export declare const LiveStreamViewerItem: React.NamedExoticComponent<LiveStreamViewerItemProps>;
+export {};
+//# sourceMappingURL=LiveStreamViewerItem.d.ts.map

package/dist/components/LiveStreamViewerItem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LiveStreamViewerItem.d.ts","sourceRoot":"","sources":["../../src/components/LiveStreamViewerItem.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAqD,MAAM,OAAO,CAAC;AAa1E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAK/C,KAAK,yBAAyB,GAAG;IAC/B,MAAM,EAAE,cAAc,CAAC;IACvB,QAAQ,EAAE,OAAO,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgBF;;GAEG;AACH,eAAO,MAAM,oBAAoB,uDAwR/B,CAAC"}

package/dist/components/LiveStreamViewerItem.js

@@ -0,0 +1,304 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo, useEffect, useMemo, useRef, useState } from 'react';
+import { Dimensions, KeyboardAvoidingView, Platform, ScrollView, StyleSheet, Text, TextInput, TouchableOpacity, View, } from 'react-native';
+import { useViewerSocket } from '../hooks/useViewerSocket';
+const { width: SCREEN_WIDTH, height: SCREEN_HEIGHT } = Dimensions.get('window');
+const CHAT_NAME_COLORS = ['#f97316', '#22c55e', '#3b82f6', '#eab308', '#ec4899', '#a855f7'];
+let RTCViewComponent = null;
+try {
+    const webrtc = require('react-native-webrtc');
+    RTCViewComponent = webrtc.RTCView;
+}
+catch {
+    // react-native-webrtc not available (e.g. Expo Go)
+}
+/**
+ * Single full-screen viewer cell. When isActive, joins the stream room and consumes video/audio.
+ */
+export const LiveStreamViewerItem = memo(function LiveStreamViewerItem({ stream, isActive, index, }) {
+    const roomId = isActive ? stream.roomId : null;
+    const { joined, joining, error, producerList, roomState, remoteStream, remoteVideoStream, webrtcUnavailable, consumeError, socket, } = useViewerSocket(roomId);
+    const viewerCount = roomState && typeof roomState.viewerCount === 'number'
+        ? roomState.viewerCount
+        : stream.viewerCount;
+    const hasVideo = producerList.some((p) => p.kind === 'video');
+    const streamObj = remoteStream;
+    const hasVideoTrack = streamObj &&
+        typeof streamObj.getVideoTracks === 'function' &&
+        streamObj.getVideoTracks().length > 0;
+    const trackCount = streamObj && typeof streamObj.getTracks === 'function' ? streamObj.getTracks().length : 0;
+    const displayStream = hasVideoTrack && remoteVideoStream ? remoteVideoStream : remoteStream;
+    const displayStreamObj = displayStream;
+    const streamURL = displayStreamObj && typeof displayStreamObj.toURL === 'function'
+        ? displayStreamObj.toURL()
+        : undefined;
+    const showVideo = RTCViewComponent && remoteStream && !!streamURL && hasVideoTrack;
+    const [chatInput, setChatInput] = useState('');
+    const [chatMessages, setChatMessages] = useState([]);
+    const seededRoomRef = useRef(null);
+    const chatListRef = useRef(null);
+    const seededFromRoomState = useMemo(() => {
+        const chat = roomState && typeof roomState === 'object' ? roomState.chat : null;
+        return Array.isArray(chat) ? chat : [];
+    }, [roomState]);
+    // Reset local chat when switching rooms.
+    useEffect(() => {
+        if (!roomId) {
+            seededRoomRef.current = null;
+            setChatMessages([]);
+            setChatInput('');
+            return;
+        }
+        if (seededRoomRef.current !== roomId) {
+            seededRoomRef.current = roomId;
+            setChatMessages([]);
+            setChatInput('');
+        }
+    }, [roomId]);
+    // Seed chat history (once per room) from roomState.chat if present.
+    useEffect(() => {
+        if (!roomId)
+            return;
+        if (seededRoomRef.current !== roomId)
+            return;
+        if (!seededFromRoomState.length)
+            return;
+        setChatMessages((prev) => {
+            if (prev.length > 0)
+                return prev;
+            const now = Date.now();
+            const normalized = seededFromRoomState
+                .map((m, i) => {
+                if (!m || typeof m !== 'object')
+                    return null;
+                const msg = m;
+                const displayName = typeof msg.displayName === 'string' ? msg.displayName : 'User';
+                const text = typeof msg.text === 'string' ? msg.text : '';
+                const timestamp = typeof msg.timestamp === 'number' ? msg.timestamp : now - (seededFromRoomState.length - i) * 1000;
+                if (!text)
+                    return null;
+                const id = `${roomId}-seed-${String(msg.peerId ?? i)}-${timestamp}-${i}`;
+                return { id, displayName, text, timestamp };
+            })
+                .filter(Boolean);
+            // Keep a reasonable amount of history, scrollable from the start.
+            return normalized;
+        });
+    }, [roomId, seededFromRoomState]);
+    // Live incoming chat messages.
+    useEffect(() => {
+        if (!socket || !roomId || !isActive)
+            return;
+        const onChatMessage = (msg) => {
+            if (!msg || typeof msg !== 'object')
+                return;
+            const m = msg;
+            const displayName = typeof m.displayName === 'string' ? m.displayName : 'User';
+            const text = typeof m.text === 'string' ? m.text : '';
+            const timestamp = typeof m.timestamp === 'number' ? m.timestamp : Date.now();
+            if (!text)
+                return;
+            const id = `${roomId}-${String(m.peerId ?? 'peer')}-${timestamp}-${text.slice(0, 8)}`;
+            setChatMessages((prev) => {
+                const next = [...prev, { id, displayName, text, timestamp }];
+                // Allow full history to be scrollable.
+                return next;
+            });
+        };
+        socket.on('chat-message', onChatMessage);
+        return () => {
+            socket.off('chat-message', onChatMessage);
+        };
+    }, [isActive, roomId, socket]);
+    // Render messages in natural order (oldest -> newest).
+    const chatData = useMemo(() => chatMessages, [chatMessages]);
+    // Always scroll to the latest message at the bottom when chat loads/updates.
+    useEffect(() => {
+        if (!chatListRef.current || chatData.length === 0)
+            return;
+        try {
+            chatListRef.current.scrollToEnd({ animated: true });
+        }
+        catch {
+            // ignore scroll errors
+        }
+    }, [chatData.length]);
+    const getNameColor = (name) => {
+        if (!name)
+            return CHAT_NAME_COLORS[0];
+        let hash = 0;
+        for (let i = 0; i < name.length; i += 1) {
+            // simple string hash
+            hash = (hash << 5) - hash + name.charCodeAt(i);
+            hash |= 0;
+        }
+        const idx = Math.abs(hash) % CHAT_NAME_COLORS.length;
+        return CHAT_NAME_COLORS[idx];
+    };
+    const sendChat = async () => {
+        const text = chatInput.trim();
+        if (!text || !socket || !joined)
+            return;
+        setChatInput('');
+        socket.emit('chat-message', { text }, (res) => {
+            if (res?.error) {
+                // eslint-disable-next-line no-console
+                console.log('[viewer] chat send error', res.error);
+            }
+        });
+    };
+    return (_jsxs(View, { style: styles.container, children: [showVideo && RTCViewComponent && streamURL ? (_jsx(RTCViewComponent, { streamURL: streamURL, stream: displayStream, style: styles.rtcView, objectFit: "cover", mirror: false }, `rtc-${trackCount}-${streamURL}`)) : (_jsxs(View, { style: styles.videoPlaceholder, children: [joining && _jsx(Text, { style: styles.placeholderText, children: "Joining..." }), error && _jsx(Text, { style: [styles.placeholderText, styles.errorText], children: error }), joined && !joining && !error && (_jsxs(_Fragment, { children: [_jsx(Text, { style: styles.liveBadge, children: "LIVE" }), _jsx(Text, { style: styles.placeholderText, children: stream.roomId }), hasVideo && webrtcUnavailable && (_jsxs(Text, { style: [styles.hintText, styles.warnText], children: ["Video needs a development build.", '\n', "Run: npx expo run:android"] })), hasVideo && consumeError && (_jsx(Text, { style: [styles.hintText, styles.errorText], children: consumeError })), hasVideo && !remoteStream && !webrtcUnavailable && !consumeError && (_jsx(Text, { style: styles.hintText, children: "Loading video..." })), !hasVideo && joined && producerList.length === 0 && (_jsxs(Text, { style: [styles.hintText, styles.warnText], children: ["Host has not started camera yet.", '\n', "Use a web client to stream, or wait for host to produce."] })), hasVideo && remoteStream && !RTCViewComponent && (_jsx(Text, { style: styles.hintText, children: "Video received (use dev build to see it)" })), hasVideo && remoteStream && RTCViewComponent && !hasVideoTrack && (_jsx(Text, { style: [styles.hintText, styles.warnText], children: "Audio only (no video track yet)" })), hasVideo && remoteStream && hasVideoTrack && !streamURL && (_jsx(Text, { style: [styles.hintText, styles.warnText], children: "Video track received but cannot display (need dev build with react-native-webrtc)" }))] }))] })), _jsxs(View, { style: styles.overlay, children: [_jsxs(View, { style: styles.topMeta, children: [_jsx(View, { style: styles.row, children: _jsxs(Text, { style: styles.roomId, numberOfLines: 1, children: ["LIVE \u00B7 ", stream.roomId] }) }), _jsxs(View, { style: styles.stats, children: [_jsxs(Text, { style: styles.statsText, children: ["\uD83D\uDC41 ", viewerCount] }), _jsxs(Text, { style: [styles.statsText, styles.statsTextSpacer], children: ["\u00B7 ", stream.producerCount, " track(s)"] })] })] }), _jsx(View, { style: styles.chatPanel, pointerEvents: "box-none", children: _jsx(KeyboardAvoidingView, { style: styles.chatKeyboardAvoider, behavior: Platform.OS === 'ios' ? 'padding' : 'height', keyboardVerticalOffset: 0, children: _jsxs(View, { style: styles.chatStack, children: [_jsx(View, { style: styles.chatListWrapper, children: _jsx(ScrollView, { ref: chatListRef, contentContainerStyle: styles.chatListContent, showsVerticalScrollIndicator: false, keyboardDismissMode: "on-drag", keyboardShouldPersistTaps: "always", nestedScrollEnabled: true, children: chatData.map((item) => (_jsxs(Text, { style: styles.chatLine, numberOfLines: 2, children: [_jsx(Text, { style: [styles.chatName, { color: getNameColor(item.displayName) }], children: item.displayName }), _jsxs(Text, { style: styles.chatText, children: [" ", item.text] })] }, item.id))) }) }), _jsxs(View, { style: styles.chatInputRow, children: [_jsx(TextInput, { style: styles.chatInput, value: chatInput, onChangeText: setChatInput, placeholder: joined ? 'Say something...' : 'Connecting...', placeholderTextColor: "#9ca3af", editable: joined && !joining && !error, onSubmitEditing: sendChat, returnKeyType: "send" }), _jsx(TouchableOpacity, { onPress: sendChat, disabled: !joined || joining || !!error || !chatInput.trim(), style: [
+                                                    styles.chatSendButton,
+                                                    (!joined || joining || !!error || !chatInput.trim()) && styles.chatSendButtonDisabled,
+                                                ], children: _jsx(Text, { style: styles.chatSendText, children: "\u27A4" }) })] })] }) }) })] })] }));
+});
+const styles = StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: '#0a0a0a',
+    },
+    rtcView: {
+        ...StyleSheet.absoluteFillObject,
+        backgroundColor: '#0a0a0a',
+    },
+    videoPlaceholder: {
+        ...StyleSheet.absoluteFillObject,
+        alignItems: 'center',
+        justifyContent: 'center',
+        backgroundColor: '#1a1a1a',
+    },
+    placeholderText: {
+        color: '#e5e5e5',
+        fontSize: 16,
+        marginVertical: 4,
+    },
+    errorText: {
+        color: '#ef4444',
+    },
+    liveBadge: {
+        color: '#ef4444',
+        fontSize: 14,
+        fontWeight: '700',
+        letterSpacing: 1,
+        marginBottom: 8,
+    },
+    hintText: {
+        color: '#737373',
+        fontSize: 12,
+        marginTop: 4,
+        textAlign: 'center',
+    },
+    warnText: {
+        color: '#f59e0b',
+        marginTop: 8,
+        paddingHorizontal: 16,
+    },
+    overlay: {
+        position: 'absolute',
+        top: 0,
+        left: 0,
+        right: 0,
+        bottom: 0,
+        padding: 16,
+        paddingBottom: 32,
+        backgroundColor: 'transparent',
+    },
+    topMeta: {
+        marginTop: 6,
+    },
+    row: {
+        flexDirection: 'row',
+        alignItems: 'center',
+    },
+    roomId: {
+        color: '#fafafa',
+        fontSize: 14,
+        fontWeight: '600',
+    },
+    stats: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        marginTop: 4,
+    },
+    statsText: {
+        color: '#a3a3a3',
+        fontSize: 12,
+    },
+    statsTextSpacer: {
+        marginLeft: 8,
+    },
+    chatPanel: {
+        position: 'absolute',
+        left: 16,
+        right: 16,
+        bottom: 16,
+    },
+    chatKeyboardAvoider: {
+        justifyContent: 'flex-end',
+    },
+    chatStack: {
+        justifyContent: 'flex-end',
+    },
+    chatListWrapper: {
+        // Limit chat area to below mid-screen (roughly bottom 1/3–1/2 of stream).
+        maxHeight: Math.round(SCREEN_HEIGHT * 0.35),
+        borderRadius: 14,
+        paddingHorizontal: 12,
+        paddingTop: 12,
+        paddingBottom: 4,
+        // Subtle transparent background so chat is readable over video.
+        backgroundColor: 'rgba(0,0,0,0.35)',
+        borderWidth: 1,
+        borderColor: 'rgba(255,255,255,0.08)',
+        // Wrap chats in a narrower column like TikTok.
+        alignSelf: 'flex-start',
+        width: '70%',
+        overflow: 'hidden',
+    },
+    chatListContent: {
+        paddingBottom: 4,
+    },
+    chatLine: {
+        color: '#e5e5e5',
+        fontSize: 13,
+        lineHeight: 18,
+        marginBottom: 4,
+    },
+    chatName: {
+        color: '#fafafa',
+        fontWeight: '700',
+    },
+    chatText: {
+        color: '#e5e5e5',
+        fontWeight: '400',
+    },
+    chatInputRow: {
+        marginTop: 10,
+        flexDirection: 'row',
+        alignItems: 'center',
+        borderRadius: 999,
+        overflow: 'hidden',
+        borderWidth: 1,
+        borderColor: 'rgba(255,255,255,0.12)',
+        backgroundColor: 'rgba(0,0,0,0.45)',
+    },
+    chatInput: {
+        flex: 1,
+        paddingHorizontal: 14,
+        paddingVertical: 10,
+        color: '#fafafa',
+        fontSize: 14,
+    },
+    chatSendButton: {
+        paddingHorizontal: 14,
+        paddingVertical: 10,
+    },
+    chatSendButtonDisabled: {
+        opacity: 0.5,
+    },
+    chatSendText: {
+        color: '#f97316',
+        fontSize: 18,
+        fontWeight: '700',
+    },
+});

package/dist/config.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Livestream module config. Host app must call setLivestreamConfig() before using the module.
+ */
+export type LivestreamConfig = {
+    /** Base HTTP URL of the livestream server (e.g. http://localhost:3000) */
+    serverHttpUrl: string;
+    /** Optional: return display name for viewer in chat/room (default: 'Viewer') */
+    getDisplayName?: () => string;
+};
+export declare function setLivestreamConfig(cfg: LivestreamConfig): void;
+export declare function getLivestreamConfig(): LivestreamConfig | null;
+export declare function getBaseUrl(): string;
+/**
+ * Socket.IO server URL.
+ *
+ * Important: socket.io-client expects an HTTP(S) URL (it will upgrade to WS/WSS itself).
+ * Using ws:// or wss:// here can cause connection issues / no fallback to polling on RN.
+ */
+export declare function getSignalingUrl(): string;
+export declare function getSignalingWsUrl(): string;
+export declare function getDisplayName(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,0EAA0E;IAC1E,aAAa,EAAE,MAAM,CAAC;IACtB,gFAAgF;IAChF,cAAc,CAAC,EAAE,MAAM,MAAM,CAAC;CAC/B,CAAC;AAIF,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,gBAAgB,GAAG,IAAI,CAE/D;AAED,wBAAgB,mBAAmB,IAAI,gBAAgB,GAAG,IAAI,CAE7D;AASD,wBAAgB,UAAU,IAAI,MAAM,CAEnC;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAKxC;AAED,wBAAgB,iBAAiB,IAAI,MAAM,CAM1C;AAED,wBAAgB,cAAc,IAAI,MAAM,CAEvC"}

package/dist/config.js

@@ -0,0 +1,44 @@
+/**
+ * Livestream module config. Host app must call setLivestreamConfig() before using the module.
+ */
+let config = null;
+export function setLivestreamConfig(cfg) {
+    config = cfg;
+}
+export function getLivestreamConfig() {
+    return config;
+}
+/** Fallback when config module is not shared (e.g. duplicate bundle); host should set this before mount. */
+const getGlobalServerUrl = () => {
+    if (typeof globalThis === 'undefined')
+        return '';
+    const g = globalThis;
+    return g?.__LIVESTREAM_SERVER_HTTP_URI ?? '';
+};
+export function getBaseUrl() {
+    return config?.serverHttpUrl ?? getGlobalServerUrl();
+}
+/**
+ * Socket.IO server URL.
+ *
+ * Important: socket.io-client expects an HTTP(S) URL (it will upgrade to WS/WSS itself).
+ * Using ws:// or wss:// here can cause connection issues / no fallback to polling on RN.
+ */
+export function getSignalingUrl() {
+    const base = getBaseUrl();
+    if (!base)
+        return '';
+    const url = new URL(base);
+    return url.origin;
+}
+export function getSignalingWsUrl() {
+    const base = getBaseUrl();
+    if (!base)
+        return '';
+    const url = new URL(base);
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:';
+    return url.origin;
+}
+export function getDisplayName() {
+    return config?.getDisplayName?.() ?? 'Viewer';
+}

package/dist/hooks/useLiveStreams.d.ts

@@ -0,0 +1,8 @@
+import type { LiveStreamInfo } from '../types';
+export declare function useLiveStreams(): {
+    streams: LiveStreamInfo[];
+    loading: boolean;
+    error: string | null;
+    refetch: () => Promise<void>;
+};
+//# sourceMappingURL=useLiveStreams.d.ts.map

package/dist/hooks/useLiveStreams.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLiveStreams.d.ts","sourceRoot":"","sources":["../../src/hooks/useLiveStreams.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,wBAAgB,cAAc,IAAI;IAChC,OAAO,EAAE,cAAc,EAAE,CAAC;IAC1B,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B,CAmBA"}

package/dist/hooks/useLiveStreams.js

@@ -0,0 +1,19 @@
+import { useCallback, useEffect, useState } from 'react';
+import { fetchActiveStreams } from '../services/livestream.service';
+export function useLiveStreams() {
+    const [streams, setStreams] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const refetch = useCallback(async () => {
+        setLoading(true);
+        setError(null);
+        const result = await fetchActiveStreams();
+        setStreams(result.streams);
+        setError(result.error ?? null);
+        setLoading(false);
+    }, []);
+    useEffect(() => {
+        refetch();
+    }, [refetch]);
+    return { streams, loading, error, refetch };
+}

package/dist/hooks/useViewerSocket.d.ts

@@ -0,0 +1,25 @@
+import { type Socket } from 'socket.io-client';
+import type { ProducerInfo } from '../types';
+type ViewerSocketState = {
+    joined: boolean;
+    joining: boolean;
+    error: string | null;
+    producerList: ProducerInfo[];
+    roomState: Record<string, unknown> | null;
+    rtpCapabilities: object | null;
+    remoteStream: unknown | null;
+    remoteVideoStream: unknown | null;
+    webrtcUnavailable: boolean;
+    consumeError: string | null;
+    /** Incremented to trigger one auto-retry when recv transport fails (ICE). */
+    consumeRetryKey: number;
+};
+/**
+ * Connects to the livestream signaling server and joins a room as viewer.
+ * When roomId changes, leaves the previous room and joins the new one (TikTok-style).
+ */
+export declare function useViewerSocket(roomId: string | null): ViewerSocketState & {
+    socket: Socket | null;
+};
+export {};
+//# sourceMappingURL=useViewerSocket.d.ts.map

package/dist/hooks/useViewerSocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useViewerSocket.d.ts","sourceRoot":"","sources":["../../src/hooks/useViewerSocket.ts"],"names":[],"mappings":"AACA,OAAO,EAAM,KAAK,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAInD,OAAO,KAAK,EAAkB,YAAY,EAAE,MAAM,UAAU,CAAC;AAE7D,KAAK,iBAAiB,GAAG;IACvB,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,YAAY,EAAE,YAAY,EAAE,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAC1C,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,YAAY,EAAE,OAAO,GAAG,IAAI,CAAC;IAC7B,iBAAiB,EAAE,OAAO,GAAG,IAAI,CAAC;IAClC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,6EAA6E;IAC7E,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG;IAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CA+apG"}

package/dist/hooks/useViewerSocket.js

@@ -0,0 +1,399 @@
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { io } from 'socket.io-client';
+import { getDisplayName } from '../config';
+import { ensureMediasoupGlobals } from '../services/mediasoup-init';
+import { getSignalingUrl } from '../services/livestream.service';
+/**
+ * Connects to the livestream signaling server and joins a room as viewer.
+ * When roomId changes, leaves the previous room and joins the new one (TikTok-style).
+ */
+export function useViewerSocket(roomId) {
+    const [state, setState] = useState({
+        joined: false,
+        joining: false,
+        error: null,
+        producerList: [],
+        roomState: null,
+        rtpCapabilities: null,
+        remoteStream: null,
+        remoteVideoStream: null,
+        webrtcUnavailable: false,
+        consumeError: null,
+        consumeRetryKey: 0,
+    });
+    const socketRef = useRef(null);
+    const roomIdRef = useRef(roomId);
+    roomIdRef.current = roomId;
+    const deviceRef = useRef(null);
+    const transportRef = useRef(null);
+    const consumedProducerIdsRef = useRef(new Set());
+    const consumeInProgressRef = useRef(false);
+    const iceServersRef = useRef([]);
+    const consumeRetryCountRef = useRef(0);
+    const displayName = useMemo(() => getDisplayName(), []);
+    const disconnect = useCallback(() => {
+        consumedProducerIdsRef.current.clear();
+        try {
+            const transport = transportRef.current;
+            if (transport?.close)
+                transport.close();
+            transportRef.current = null;
+            deviceRef.current = null;
+        }
+        catch {
+            // ignore
+        }
+        const s = socketRef.current;
+        if (s) {
+            s.disconnect();
+            s.removeAllListeners();
+            socketRef.current = null;
+        }
+        setState({
+            joined: false,
+            joining: false,
+            error: null,
+            producerList: [],
+            roomState: null,
+            rtpCapabilities: null,
+            remoteStream: null,
+            remoteVideoStream: null,
+            webrtcUnavailable: false,
+            consumeError: null,
+            consumeRetryKey: 0,
+        });
+        consumeRetryCountRef.current = 0;
+    }, []);
+    const setRemoteStreams = useCallback((stream) => {
+        if (!stream) {
+            setState((prev) => ({ ...prev, remoteStream: null, remoteVideoStream: null }));
+            return;
+        }
+        const MediaStreamCtor = global.MediaStream;
+        const videoTracks = typeof stream.getVideoTracks === 'function' ? stream.getVideoTracks() : [];
+        const videoStream = MediaStreamCtor && Array.isArray(videoTracks) && videoTracks.length > 0
+            ? new MediaStreamCtor(videoTracks)
+            : stream;
+        setState((prev) => ({ ...prev, remoteStream: stream, remoteVideoStream: videoStream }));
+    }, []);
+    useEffect(() => {
+        if (!roomId) {
+            disconnect();
+            return;
+        }
+        const signalingUrl = getSignalingUrl();
+        if (!signalingUrl) {
+            setState((prev) => ({ ...prev, error: 'Livestream server not configured', joining: false }));
+            return;
+        }
+        setState((prev) => ({ ...prev, joining: true, error: null }));
+        const JOIN_TIMEOUT_MS = 12000;
+        const joinTimeout = setTimeout(() => {
+            if (roomIdRef.current !== roomId)
+                return;
+            setState((prev) => {
+                if (!prev.joining || prev.joined)
+                    return prev;
+                return {
+                    ...prev,
+                    joining: false,
+                    joined: false,
+                    error: 'Join timed out. Check server URL and network.',
+                };
+            });
+        }, JOIN_TIMEOUT_MS);
+        // Match web client (Client/src/streamService.js): websocket first, then polling.
+        const socket = io(signalingUrl, {
+            transports: ['websocket', 'polling'],
+            reconnection: true,
+            autoConnect: true,
+            timeout: 10000,
+        });
+        socketRef.current = socket;
+        socket.on('connect', () => {
+            socket.emit('join-room', {
+                roomId,
+                role: 'viewer',
+                displayName,
+            }, (res) => {
+                clearTimeout(joinTimeout);
+                if (roomIdRef.current !== roomId)
+                    return;
+                if (res?.error) {
+                    setState((prev) => ({
+                        ...prev,
+                        joining: false,
+                        joined: false,
+                        error: res.error ?? 'Failed to join',
+                    }));
+                    return;
+                }
+                const iceFromJoin = res.iceServers;
+                if (Array.isArray(iceFromJoin) && iceFromJoin.length > 0) {
+                    iceServersRef.current = iceFromJoin;
+                }
+                setState((prev) => ({
+                    ...prev,
+                    joining: false,
+                    joined: true,
+                    producerList: res.producerList ?? [],
+                    roomState: res.roomState ?? null,
+                    rtpCapabilities: res.rtpCapabilities ?? null,
+                    error: null,
+                }));
+            });
+        });
+        socket.on('connect_error', (err) => {
+            clearTimeout(joinTimeout);
+            setState((prev) => ({
+                ...prev,
+                joining: false,
+                joined: false,
+                error: err?.message ?? 'Connection failed',
+            }));
+        });
+        socket.on('ice-servers', (servers) => {
+            iceServersRef.current = Array.isArray(servers) ? servers : [];
+        });
+        socket.on('room-updated', (payload) => {
+            if (payload?.producerList) {
+                setState((prev) => ({ ...prev, producerList: payload.producerList ?? [] }));
+            }
+        });
+        socket.on('new-producer', () => {
+            socket.emit('get-producers', null, (resp) => {
+                if (resp?.producerList) {
+                    setState((prev) => ({ ...prev, producerList: resp.producerList ?? [] }));
+                }
+            });
+        });
+        return () => {
+            clearTimeout(joinTimeout);
+            disconnect();
+        };
+    }, [roomId, displayName, disconnect]);
+    // Consume flow: create device, recv transport, connect, consume each producer → remoteStream
+    useEffect(() => {
+        const socket = socketRef.current;
+        const { joined, rtpCapabilities, producerList } = state;
+        if (!joined || !rtpCapabilities || !producerList?.length || !socket || state.remoteStream)
+            return;
+        if (roomIdRef.current !== roomId)
+            return;
+        if (consumeInProgressRef.current)
+            return;
+        consumeInProgressRef.current = true;
+        let cancelled = false;
+        const runConsume = async () => {
+            if (!ensureMediasoupGlobals()) {
+                consumeInProgressRef.current = false;
+                if (!cancelled) {
+                    setState((prev) => ({ ...prev, webrtcUnavailable: true, consumeError: null }));
+                }
+                return;
+            }
+            try {
+                setState((prev) => ({ ...prev, consumeError: null }));
+                const mediasoupClient = require('mediasoup-client');
+                const device = new mediasoupClient.Device();
+                deviceRef.current = device;
+                await device.load({ routerRtpCapabilities: rtpCapabilities });
+                if (cancelled)
+                    return;
+                const transportOpts = await new Promise((resolve, reject) => {
+                    socket.emit('create-webrtc-transport', {}, (res) => {
+                        if (res?.error) {
+                            reject(new Error(res.error));
+                            return;
+                        }
+                        if (res?.id && res?.iceParameters && res?.dtlsParameters) {
+                            resolve({
+                                id: res.id,
+                                iceParameters: res.iceParameters,
+                                iceCandidates: res.iceCandidates ?? [],
+                                dtlsParameters: res.dtlsParameters,
+                            });
+                        }
+                        else {
+                            reject(new Error('Invalid transport response'));
+                        }
+                    });
+                });
+                if (cancelled)
+                    return;
+                const recvOptions = { ...transportOpts, iceTransportPolicy: 'all' };
+                if (iceServersRef.current.length > 0) {
+                    recvOptions.iceServers = iceServersRef.current;
+                }
+                // Debug: log recv transport options for troubleshooting (kept small).
+                // eslint-disable-next-line no-console
+                console.log('[viewer] recv options', {
+                    hasIceServers: !!recvOptions.iceServers && recvOptions.iceServers.length > 0,
+                    iceServerCount: recvOptions.iceServers?.length ?? 0,
+                });
+                const transport = device.createRecvTransport(recvOptions);
+                transportRef.current = transport;
+                // Wire DTLS connect; do not block on connectionstatechange before consuming.
+                transport.on('connect', ({ dtlsParameters }, callback, errback) => {
+                    socket.emit('connect-transport', { transportId: transport.id, dtlsParameters }, (res) => {
+                        if (res?.error)
+                            errback(new Error(res.error));
+                        else
+                            callback();
+                    });
+                });
+                transport.on('connectionstatechange', (connectionState) => {
+                    // eslint-disable-next-line no-console
+                    console.log('[viewer] recv transport state', connectionState);
+                    if (connectionState === 'failed' || connectionState === 'closed') {
+                        const transportToClose = transportRef.current;
+                        try {
+                            if (transportToClose?.close)
+                                transportToClose.close();
+                        }
+                        catch {
+                            // ignore
+                        }
+                        transportRef.current = null;
+                        deviceRef.current = null;
+                        consumedProducerIdsRef.current.clear();
+                        if (connectionState === 'failed' && consumeRetryCountRef.current < 1) {
+                            consumeRetryCountRef.current += 1;
+                            consumeInProgressRef.current = false;
+                            setState((prev) => ({
+                                ...prev,
+                                consumeError: null,
+                                consumeRetryKey: prev.consumeRetryKey + 1,
+                            }));
+                        }
+                        else {
+                            setState((prev) => ({
+                                ...prev,
+                                consumeError: prev.consumeError ?? 'Connection failed. Check network or try again.',
+                            }));
+                        }
+                    }
+                });
+                const MediaStreamCtor = global.MediaStream;
+                if (!MediaStreamCtor)
+                    return;
+                const stream = new MediaStreamCtor();
+                if (!stream)
+                    return;
+                for (const producer of producerList) {
+                    if (cancelled)
+                        break;
+                    const consumeRes = await new Promise((resolve, reject) => {
+                        socket.emit('consume', { transportId: transport.id, producerId: producer.id, rtpCapabilities: device.rtpCapabilities }, (res) => {
+                            if (res?.error) {
+                                reject(new Error(res.error));
+                                return;
+                            }
+                            if (res?.id && res?.producerId && res?.kind && res?.rtpParameters) {
+                                resolve({ id: res.id, producerId: res.producerId, kind: res.kind, rtpParameters: res.rtpParameters });
+                            }
+                            else {
+                                reject(new Error('Invalid consume response'));
+                            }
+                        });
+                    });
+                    const consumer = await transport.consume({
+                        id: consumeRes.id,
+                        producerId: consumeRes.producerId,
+                        kind: consumeRes.kind,
+                        rtpParameters: consumeRes.rtpParameters,
+                    });
+                    const track = consumer.track;
+                    if (track)
+                        stream.addTrack(track);
+                    consumedProducerIdsRef.current.add(producer.id);
+                }
+                const trackCount = typeof stream.getTracks === 'function' ? stream.getTracks().length : 0;
+                if (!cancelled) {
+                    consumeRetryCountRef.current = 0;
+                    if (trackCount > 0) {
+                        setRemoteStreams(stream);
+                    }
+                    else {
+                        setState((prev) => ({
+                            ...prev,
+                            remoteStream: null,
+                            consumeError: 'No video or audio track received from host.',
+                        }));
+                    }
+                }
+            }
+            catch (err) {
+                if (!cancelled) {
+                    const message = err instanceof Error ? err.message : 'Video failed to load';
+                    // eslint-disable-next-line no-console
+                    console.log('[viewer] consume error', message);
+                    setState((prev) => ({ ...prev, remoteStream: null, consumeError: message }));
+                }
+            }
+            finally {
+                consumeInProgressRef.current = false;
+            }
+        };
+        runConsume();
+        return () => {
+            cancelled = true;
+        };
+    }, [roomId, state.joined, state.rtpCapabilities, state.producerList?.length ?? 0, state.remoteStream, state.consumeRetryKey]);
+    // Consume new producers added after we already have a stream
+    useEffect(() => {
+        const socket = socketRef.current;
+        const transport = transportRef.current;
+        const device = deviceRef.current;
+        const stream = state.remoteStream;
+        if (!socket || !transport || !device || !stream || !state.producerList?.length)
+            return;
+        if (roomIdRef.current !== roomId)
+            return;
+        const toConsume = state.producerList.filter((p) => !consumedProducerIdsRef.current.has(p.id));
+        if (toConsume.length === 0)
+            return;
+        let cancelled = false;
+        (async () => {
+            for (const producer of toConsume) {
+                if (cancelled)
+                    break;
+                try {
+                    const consumeRes = await new Promise((resolve, reject) => {
+                        socket.emit('consume', { transportId: transport.id, producerId: producer.id, rtpCapabilities: device.rtpCapabilities }, (res) => {
+                            if (res?.error)
+                                reject(new Error(res.error));
+                            else if (res?.id && res?.producerId && res?.kind && res?.rtpParameters) {
+                                resolve({ id: res.id, producerId: res.producerId, kind: res.kind, rtpParameters: res.rtpParameters });
+                            }
+                            else
+                                reject(new Error('Invalid consume response'));
+                        });
+                    });
+                    const consumer = await transport.consume({
+                        id: consumeRes.id,
+                        producerId: consumeRes.producerId,
+                        kind: consumeRes.kind,
+                        rtpParameters: consumeRes.rtpParameters,
+                    });
+                    const track = consumer.track;
+                    if (track && !cancelled) {
+                        stream.addTrack(track);
+                        consumedProducerIdsRef.current.add(producer.id);
+                        setRemoteStreams(stream);
+                    }
+                }
+                catch {
+                    // ignore per-producer errors
+                }
+            }
+        })();
+        return () => {
+            cancelled = true;
+        };
+    }, [roomId, state.remoteStream, state.producerList]);
+    return {
+        ...state,
+        socket: socketRef.current,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @livestream/core — Reusable livestream module for React Native (Expo).
+ * Configure with setLivestreamConfig() before using components/hooks.
+ */
+export { setLivestreamConfig, getLivestreamConfig, getBaseUrl, getSignalingUrl, getSignalingWsUrl, getDisplayName, } from './config';
+export type { LivestreamConfig } from './config';
+export { fetchActiveStreams } from './services/livestream.service';
+export type { FetchStreamsResult } from './services/livestream.service';
+export { ensureMediasoupGlobals } from './services/mediasoup-init';
+export { useViewerSocket } from './hooks/useViewerSocket';
+export { useLiveStreams } from './hooks/useLiveStreams';
+export { LiveStreamFeed } from './components/LiveStreamFeed';
+export { LiveStreamViewerItem } from './components/LiveStreamViewerItem';
+export type { LiveStreamInfo, ProducerInfo, JoinRoomResult, RoomState } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EACnB,UAAU,EACV,eAAe,EACf,iBAAiB,EACjB,cAAc,GACf,MAAM,UAAU,CAAC;AAClB,YAAY,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,YAAY,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAExD,OAAO,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAEzE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -0,0 +1,11 @@
+/**
+ * @livestream/core — Reusable livestream module for React Native (Expo).
+ * Configure with setLivestreamConfig() before using components/hooks.
+ */
+export { setLivestreamConfig, getLivestreamConfig, getBaseUrl, getSignalingUrl, getSignalingWsUrl, getDisplayName, } from './config';
+export { fetchActiveStreams } from './services/livestream.service';
+export { ensureMediasoupGlobals } from './services/mediasoup-init';
+export { useViewerSocket } from './hooks/useViewerSocket';
+export { useLiveStreams } from './hooks/useLiveStreams';
+export { LiveStreamFeed } from './components/LiveStreamFeed';
+export { LiveStreamViewerItem } from './components/LiveStreamViewerItem';

package/dist/services/livestream.service.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Livestream API: fetch active streams from HTTP; signaling URL from config.
+ */
+import type { LiveStreamInfo } from '../types';
+export type FetchStreamsResult = {
+    streams: LiveStreamInfo[];
+    error?: never;
+} | {
+    streams: [];
+    error: string;
+};
+export declare function fetchActiveStreams(): Promise<FetchStreamsResult>;
+export declare function getSignalingUrl(): string;
+export declare function getSignalingWsUrl(): string;
+//# sourceMappingURL=livestream.service.d.ts.map

package/dist/services/livestream.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"livestream.service.d.ts","sourceRoot":"","sources":["../../src/services/livestream.service.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,MAAM,kBAAkB,GAC1B;IAAE,OAAO,EAAE,cAAc,EAAE,CAAC;IAAC,KAAK,CAAC,EAAE,KAAK,CAAA;CAAE,GAC5C;IAAE,OAAO,EAAE,EAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEnC,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAoBtE;AAED,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAGD,wBAAgB,iBAAiB,IAAI,MAAM,CAE1C"}

package/dist/services/livestream.service.js

@@ -0,0 +1,33 @@
+/**
+ * Livestream API: fetch active streams from HTTP; signaling URL from config.
+ */
+import { getBaseUrl, getSignalingUrl as getUrlFromConfig } from '../config';
+export async function fetchActiveStreams() {
+    const base = getBaseUrl();
+    if (!base) {
+        return { streams: [], error: 'Livestream server not configured' };
+    }
+    try {
+        const url = `${base.replace(/\/$/, '')}/api/live-streams`;
+        const res = await fetch(url, { method: 'GET' });
+        if (!res.ok) {
+            return { streams: [], error: `HTTP ${res.status}` };
+        }
+        const data = (await res.json());
+        if (data.error) {
+            return { streams: [], error: data.error };
+        }
+        return { streams: data.streams ?? [] };
+    }
+    catch (e) {
+        const message = e instanceof Error ? e.message : 'Unknown error';
+        return { streams: [], error: message };
+    }
+}
+export function getSignalingUrl() {
+    return getUrlFromConfig();
+}
+// Back-compat alias (socket.io-client should use HTTP(S) URL; see getSignalingUrl()).
+export function getSignalingWsUrl() {
+    return getSignalingUrl();
+}

package/dist/services/mediasoup-init.d.ts

@@ -0,0 +1,6 @@
+/**
+ * One-time init for mediasoup-client in React Native.
+ * Call registerGlobals() from react-native-webrtc before creating any Device.
+ */
+export declare function ensureMediasoupGlobals(): boolean;
+//# sourceMappingURL=mediasoup-init.d.ts.map

package/dist/services/mediasoup-init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mediasoup-init.d.ts","sourceRoot":"","sources":["../../src/services/mediasoup-init.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,wBAAgB,sBAAsB,IAAI,OAAO,CAahD"}

package/dist/services/mediasoup-init.js

@@ -0,0 +1,21 @@
+/**
+ * One-time init for mediasoup-client in React Native.
+ * Call registerGlobals() from react-native-webrtc before creating any Device.
+ */
+let globalsRegistered = false;
+export function ensureMediasoupGlobals() {
+    if (globalsRegistered)
+        return true;
+    try {
+        const { registerGlobals } = require('react-native-webrtc');
+        if (typeof registerGlobals === 'function') {
+            registerGlobals();
+            globalsRegistered = true;
+            return true;
+        }
+    }
+    catch {
+        // react-native-webrtc not available (e.g. Expo Go without dev client)
+    }
+    return false;
+}

package/dist/types.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Livestream module types.
+ * Stream list from GET /api/live-streams; room signaling via Socket.IO.
+ */
+export type LiveStreamInfo = {
+    roomId: string;
+    viewerCount: number;
+    producerCount: number;
+};
+export type ProducerInfo = {
+    id: string;
+    kind: 'audio' | 'video';
+    peerId: string;
+};
+export type JoinRoomPayload = {
+    roomId: string;
+    role: 'host' | 'viewer';
+    displayName?: string;
+};
+export type JoinRoomResult = {
+    rtpCapabilities?: object;
+    producerList?: ProducerInfo[];
+    roomState?: RoomState;
+    error?: string;
+};
+export type RoomState = {
+    chat?: unknown[];
+    likes?: number;
+    viewerCount?: number;
+    [key: string]: unknown;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,OAAO,GAAG,OAAO,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,cAAc,GAAG;IAC3B,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,YAAY,EAAE,CAAC;IAC9B,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC"}

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Livestream module types.
+ * Stream list from GET /api/live-streams; room signaling via Socket.IO.
+ */
+export {};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "kasunk99-livestream-core",
+  "version": "0.1.0",
+  "description": "Reusable livestream viewer/host module for React Native (Expo) — mediasoup + Socket.IO",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "peerDependencies": {
+    "mediasoup-client": "^3.6.0",
+    "react": ">=18.0.0",
+    "react-native": "*",
+    "react-native-webrtc": ">=118.0.0",
+    "socket.io-client": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0",
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.8",
+    "mediasoup-client": "^3.18.7",
+    "react-native": "^0.84.1",
+    "react-native-webrtc": "^124.0.7",
+    "rimraf": "^6.1.3",
+    "socket.io-client": "^4.8.3",
+    "typescript": "~5.3.0"
+  }
+}