react-native-mp3 0.1.0

package/lib/index.d.ts

@@ -0,0 +1,144 @@
+import { ScannerEvents, PlayerEvents, RepeatMode, EqualizerPresets, AudioExtensions } from './utils/constants';
+import { Album, Artist, PlaybackState, ScannerOptions, Song } from './types';
+export { Song, Album, Artist, Playlist, PlaybackState, EqualizerPreset, ScannerOptions, PlayerOptions, } from './types/common.types';
+export type { ScannerEvents as ScannerEventsType, ScannerEventType, } from './types/scanner.types';
+export type { PlayerEvents as PlayerEventsType, PlayerEventType, } from './types/player.types';
+export { ScannerEvents, PlayerEvents, RepeatMode, EqualizerPresets, AudioExtensions, };
+export { useMusicPlayer } from './hooks/useMusicPlayer';
+export { useMusicScanner } from './hooks/useMusicScanner';
+export { usePermissions } from './hooks/usePermissions';
+export declare const Scanner: {
+    requestStoragePermission: () => Promise<boolean>;
+    checkPermissionStatus: () => Promise<boolean>;
+    scanMusicFiles: (options?: ScannerOptions) => Promise<any>;
+    getCachedSongs: (options?: any) => Promise<Song[]>;
+    deleteSong: (songId: string) => Promise<boolean>;
+    addToFavorites: (songId: string) => Promise<boolean>;
+    removeFromFavorites: (songId: string) => Promise<boolean>;
+    getAlbums: () => Promise<Album[]>;
+    getArtists: () => Promise<Artist[]>;
+    searchSongs: (query: string) => Promise<Song[]>;
+    clearCache: () => Promise<boolean>;
+    startFileMonitoring: () => void;
+    stopFileMonitoring: () => void;
+    addEventListener: (event: string, listener: (data: any) => void) => {
+        remove: () => void;
+    };
+    removeAllListeners: (event?: string) => void;
+};
+export declare const Player: {
+    play: (uri: string) => Promise<void>;
+    playFromQueue: (index: number) => void;
+    pause: () => void;
+    stop: () => void;
+    seekTo: (position: number) => void;
+    skipToNext: () => void;
+    skipToPrevious: () => void;
+    setVolume: (volume: number) => void;
+    setPlaybackRate: (rate: number) => void;
+    setQueue: (songs: Song[]) => void;
+    addToQueue: (songs: Song[]) => void;
+    clearQueue: () => void;
+    getQueue: () => Promise<Song[]>;
+    getCurrentTrack: () => Promise<Song>;
+    getPlaybackState: () => Promise<PlaybackState>;
+    getCurrentTime: () => Promise<number>;
+    getDuration: () => Promise<number>;
+    isPlaying: () => Promise<boolean>;
+    setRepeatMode: (mode: "none" | "one" | "all") => void;
+    setShuffleMode: (enabled: boolean) => void;
+    setEqualizerPreset: (preset: string) => void;
+    setEqualizerBands: (bands: number[]) => void;
+    getEqualizerPresets: () => Promise<string[]>;
+    enableEqualizer: (enabled: boolean) => void;
+    setSleepTimer: (minutes: number) => void;
+    cancelSleepTimer: () => void;
+    setupBackgroundPlayback: (config?: any) => void;
+    stopBackgroundPlayback: () => void;
+    addEventListener: (event: string, listener: (data: any) => void) => {
+        remove: () => void;
+    };
+    removeAllListeners: (event?: string) => void;
+};
+export declare const Metadata: {
+    extractMetadata: (uri: string) => Promise<any>;
+    getAlbumArt: (uri: string, size?: number) => Promise<string>;
+    getLyrics: (uri: string) => Promise<string | null>;
+    updateMetadata: (uri: string, metadata: any) => Promise<boolean>;
+};
+export declare const Notifications: {
+    setupNotificationChannel: () => void;
+    updateNotification: (metadata: any) => void;
+    hideNotification: () => void;
+    showNotification: () => void;
+};
+declare const _default: {
+    Scanner: {
+        requestStoragePermission: () => Promise<boolean>;
+        checkPermissionStatus: () => Promise<boolean>;
+        scanMusicFiles: (options?: ScannerOptions) => Promise<any>;
+        getCachedSongs: (options?: any) => Promise<Song[]>;
+        deleteSong: (songId: string) => Promise<boolean>;
+        addToFavorites: (songId: string) => Promise<boolean>;
+        removeFromFavorites: (songId: string) => Promise<boolean>;
+        getAlbums: () => Promise<Album[]>;
+        getArtists: () => Promise<Artist[]>;
+        searchSongs: (query: string) => Promise<Song[]>;
+        clearCache: () => Promise<boolean>;
+        startFileMonitoring: () => void;
+        stopFileMonitoring: () => void;
+        addEventListener: (event: string, listener: (data: any) => void) => {
+            remove: () => void;
+        };
+        removeAllListeners: (event?: string) => void;
+    };
+    Player: {
+        play: (uri: string) => Promise<void>;
+        playFromQueue: (index: number) => void;
+        pause: () => void;
+        stop: () => void;
+        seekTo: (position: number) => void;
+        skipToNext: () => void;
+        skipToPrevious: () => void;
+        setVolume: (volume: number) => void;
+        setPlaybackRate: (rate: number) => void;
+        setQueue: (songs: Song[]) => void;
+        addToQueue: (songs: Song[]) => void;
+        clearQueue: () => void;
+        getQueue: () => Promise<Song[]>;
+        getCurrentTrack: () => Promise<Song>;
+        getPlaybackState: () => Promise<PlaybackState>;
+        getCurrentTime: () => Promise<number>;
+        getDuration: () => Promise<number>;
+        isPlaying: () => Promise<boolean>;
+        setRepeatMode: (mode: "none" | "one" | "all") => void;
+        setShuffleMode: (enabled: boolean) => void;
+        setEqualizerPreset: (preset: string) => void;
+        setEqualizerBands: (bands: number[]) => void;
+        getEqualizerPresets: () => Promise<string[]>;
+        enableEqualizer: (enabled: boolean) => void;
+        setSleepTimer: (minutes: number) => void;
+        cancelSleepTimer: () => void;
+        setupBackgroundPlayback: (config?: any) => void;
+        stopBackgroundPlayback: () => void;
+        addEventListener: (event: string, listener: (data: any) => void) => {
+            remove: () => void;
+        };
+        removeAllListeners: (event?: string) => void;
+    };
+    Metadata: {
+        extractMetadata: (uri: string) => Promise<any>;
+        getAlbumArt: (uri: string, size?: number) => Promise<string>;
+        getLyrics: (uri: string) => Promise<string | null>;
+        updateMetadata: (uri: string, metadata: any) => Promise<boolean>;
+    };
+    Notifications: {
+        setupNotificationChannel: () => void;
+        updateNotification: (metadata: any) => void;
+        hideNotification: () => void;
+        showNotification: () => void;
+    };
+};
+export default _default;
+export declare const isAndroid: boolean;
+export declare const isIOS: boolean;

package/lib/index.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIOS = exports.isAndroid = exports.Notifications = exports.Metadata = exports.Player = exports.Scanner = exports.usePermissions = exports.useMusicScanner = exports.useMusicPlayer = exports.AudioExtensions = exports.EqualizerPresets = exports.RepeatMode = exports.PlayerEvents = exports.ScannerEvents = void 0;
+const react_native_1 = require("react-native");
+// Import constants
+const constants_1 = require("./utils/constants");
+Object.defineProperty(exports, "ScannerEvents", { enumerable: true, get: function () { return constants_1.ScannerEvents; } });
+Object.defineProperty(exports, "PlayerEvents", { enumerable: true, get: function () { return constants_1.PlayerEvents; } });
+Object.defineProperty(exports, "RepeatMode", { enumerable: true, get: function () { return constants_1.RepeatMode; } });
+Object.defineProperty(exports, "EqualizerPresets", { enumerable: true, get: function () { return constants_1.EqualizerPresets; } });
+Object.defineProperty(exports, "AudioExtensions", { enumerable: true, get: function () { return constants_1.AudioExtensions; } });
+// Hooks
+var useMusicPlayer_1 = require("./hooks/useMusicPlayer");
+Object.defineProperty(exports, "useMusicPlayer", { enumerable: true, get: function () { return useMusicPlayer_1.useMusicPlayer; } });
+var useMusicScanner_1 = require("./hooks/useMusicScanner");
+Object.defineProperty(exports, "useMusicScanner", { enumerable: true, get: function () { return useMusicScanner_1.useMusicScanner; } });
+var usePermissions_1 = require("./hooks/usePermissions");
+Object.defineProperty(exports, "usePermissions", { enumerable: true, get: function () { return usePermissions_1.usePermissions; } });
+// Optional UI Components (if needed)
+// export { MusicPlayerUI } from './components/MusicPlayerUI';
+// export { MusicList } from './components/MusicList';
+// Native Modules
+const { ScannerModule, PlayerModule, MetadataModule, NotificationModule } = react_native_1.NativeModules;
+// Event Emitters
+const scannerEventEmitter = new react_native_1.NativeEventEmitter(ScannerModule);
+const playerEventEmitter = new react_native_1.NativeEventEmitter(PlayerModule);
+// Check if native modules are available
+if (!ScannerModule || !PlayerModule) {
+    console.warn('react-native-mp3 native modules are not available. Make sure to link the package properly.');
+}
+// Scanner Module Functions
+exports.Scanner = {
+    // Permission
+    requestStoragePermission: () => ScannerModule.requestStoragePermission(),
+    checkPermissionStatus: () => ScannerModule.checkPermissionStatus(),
+    // Scanning
+    scanMusicFiles: (options) => ScannerModule.scanMusicFiles(options || {}),
+    getCachedSongs: (options) => ScannerModule.getCachedSongs(options || {}),
+    // File Operations
+    deleteSong: (songId) => ScannerModule.deleteSong(songId),
+    addToFavorites: (songId) => ScannerModule.addToFavorites(songId),
+    removeFromFavorites: (songId) => ScannerModule.removeFromFavorites(songId),
+    // Metadata
+    getAlbums: () => ScannerModule.getAlbums(),
+    getArtists: () => ScannerModule.getArtists(),
+    searchSongs: (query) => ScannerModule.searchSongs(query),
+    // Cache Management
+    clearCache: () => ScannerModule.clearCache(),
+    // File Monitoring
+    startFileMonitoring: () => ScannerModule.startFileMonitoring(),
+    stopFileMonitoring: () => ScannerModule.stopFileMonitoring(),
+    // Events
+    addEventListener: (event, listener) => {
+        const subscription = scannerEventEmitter.addListener(event, listener);
+        return { remove: () => subscription.remove() };
+    },
+    removeAllListeners: (event) => {
+        if (event) {
+            scannerEventEmitter.removeAllListeners(event);
+        }
+        else {
+            // Remove all events by specifying each event type
+            const scannerEventTypes = Object.values(constants_1.ScannerEvents);
+            scannerEventTypes.forEach(eventType => {
+                scannerEventEmitter.removeAllListeners(eventType);
+            });
+        }
+    },
+};
+// Player Module Functions
+exports.Player = {
+    // Playback Control
+    play: (uri) => PlayerModule.play(uri),
+    playFromQueue: (index) => PlayerModule.playFromQueue(index),
+    pause: () => PlayerModule.pause(),
+    stop: () => PlayerModule.stop(),
+    seekTo: (position) => PlayerModule.seekTo(position),
+    skipToNext: () => PlayerModule.skipToNext(),
+    skipToPrevious: () => PlayerModule.skipToPrevious(),
+    setVolume: (volume) => PlayerModule.setVolume(volume),
+    setPlaybackRate: (rate) => PlayerModule.setPlaybackRate(rate),
+    // Queue Management
+    setQueue: (songs) => PlayerModule.setQueue(songs),
+    addToQueue: (songs) => PlayerModule.addToQueue(songs),
+    clearQueue: () => PlayerModule.clearQueue(),
+    getQueue: () => PlayerModule.getQueue(),
+    getCurrentTrack: () => PlayerModule.getCurrentTrack(),
+    // Playback State
+    getPlaybackState: () => PlayerModule.getPlaybackState(),
+    getCurrentTime: () => PlayerModule.getCurrentTime(),
+    getDuration: () => PlayerModule.getDuration(),
+    isPlaying: () => PlayerModule.isPlaying(),
+    // Playback Modes
+    setRepeatMode: (mode) => PlayerModule.setRepeatMode(mode),
+    setShuffleMode: (enabled) => PlayerModule.setShuffleMode(enabled),
+    // Equalizer
+    setEqualizerPreset: (preset) => PlayerModule.setEqualizerPreset(preset),
+    setEqualizerBands: (bands) => PlayerModule.setEqualizerBands(bands),
+    getEqualizerPresets: () => PlayerModule.getEqualizerPresets(),
+    enableEqualizer: (enabled) => PlayerModule.enableEqualizer(enabled),
+    // Sleep Timer
+    setSleepTimer: (minutes) => PlayerModule.setSleepTimer(minutes),
+    cancelSleepTimer: () => PlayerModule.cancelSleepTimer(),
+    // Background Playback
+    setupBackgroundPlayback: (config) => PlayerModule.setupBackgroundPlayback(config || {}),
+    stopBackgroundPlayback: () => PlayerModule.stopBackgroundPlayback(),
+    // Events
+    addEventListener: (event, listener) => {
+        const subscription = playerEventEmitter.addListener(event, listener);
+        return { remove: () => subscription.remove() };
+    },
+    removeAllListeners: (event) => {
+        if (event) {
+            playerEventEmitter.removeAllListeners(event);
+        }
+        else {
+            // Remove all events by specifying each event type
+            const playerEventTypes = Object.values(constants_1.PlayerEvents);
+            playerEventTypes.forEach(eventType => {
+                playerEventEmitter.removeAllListeners(eventType);
+            });
+        }
+    },
+};
+// Metadata Module Functions
+exports.Metadata = {
+    extractMetadata: (uri) => MetadataModule.extractMetadata(uri),
+    getAlbumArt: (uri, size) => MetadataModule.getAlbumArt(uri, size || 300),
+    getLyrics: (uri) => MetadataModule.getLyrics(uri),
+    updateMetadata: (uri, metadata) => MetadataModule.updateMetadata(uri, metadata),
+};
+// Notification Module Functions
+exports.Notifications = {
+    setupNotificationChannel: () => NotificationModule.setupNotificationChannel(),
+    updateNotification: (metadata) => NotificationModule.updateNotification(metadata),
+    hideNotification: () => NotificationModule.hideNotification(),
+    showNotification: () => NotificationModule.showNotification(),
+};
+// Default export
+exports.default = {
+    Scanner: exports.Scanner,
+    Player: exports.Player,
+    Metadata: exports.Metadata,
+    Notifications: exports.Notifications,
+};
+// Platform check
+exports.isAndroid = react_native_1.Platform.OS === 'android';
+exports.isIOS = react_native_1.Platform.OS === 'ios';

package/lib/types/common.types.d.ts

@@ -0,0 +1,79 @@
+export interface Song {
+    id: string;
+    title: string;
+    artist: string;
+    album: string;
+    duration: number;
+    path: string;
+    uri: string;
+    albumArtUri?: string;
+    size: number;
+    mimeType: string;
+    trackNumber: number;
+    year?: number;
+    genre?: string;
+    dateAdded: number;
+    lastModified: number;
+    isFavorite: boolean;
+    playCount: number;
+    lastPlayed?: number;
+    bitrate?: number;
+    sampleRate?: number;
+    channels?: number;
+    composer?: string;
+    bookmark: number;
+    isPodcast: boolean;
+    rating?: number;
+}
+export interface Album {
+    name: string;
+    songCount: number;
+    albumArtUri?: string;
+    artist?: string;
+    year?: number;
+}
+export interface Artist {
+    name: string;
+    songCount: number;
+    albumCount: number;
+}
+export interface Playlist {
+    id: string;
+    name: string;
+    songCount: number;
+    thumbnailUri?: string;
+    createdAt: number;
+}
+export interface PlaybackState {
+    isPlaying: boolean;
+    currentTime: number;
+    duration: number;
+    buffered?: number;
+    playbackRate: number;
+    volume: number;
+    repeatMode: 'none' | 'one' | 'all';
+    shuffleMode: boolean;
+    currentSong?: Song;
+    queue: Song[];
+    queuePosition: number;
+    error?: string;
+}
+export interface EqualizerPreset {
+    name: string;
+    bands: number[];
+}
+export interface ScannerOptions {
+    forceRescan?: boolean;
+    paths?: string[];
+    maxFiles?: number;
+    extensions?: string[];
+}
+export interface PlayerOptions {
+    autoPlay?: boolean;
+    keepAwake?: boolean;
+    volume?: number;
+    speed?: number;
+    repeatMode?: 'none' | 'one' | 'all';
+    audioFocus?: boolean;
+    ducking?: boolean;
+}

package/lib/types/common.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/index.d.ts

@@ -0,0 +1,3 @@
+export type { Song, Album, Artist, Playlist, PlaybackState, EqualizerPreset, ScannerOptions, PlayerOptions } from './common.types';
+export type { ScannerEvents, ScannerEventType } from './scanner.types';
+export type { PlayerEvents, PlayerEventType } from './player.types';

package/lib/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/player.types.d.ts

@@ -0,0 +1,35 @@
+export interface PlayerEvents {
+    PLAYBACK_STATE_CHANGED: {
+        isPlaying: boolean;
+        currentTime: number;
+        duration: number;
+        buffered?: number;
+    };
+    PLAYBACK_QUEUE_CHANGED: {
+        queue: any[];
+        position: number;
+    };
+    PLAYBACK_ERROR: {
+        error: string;
+        songId?: string;
+    };
+    PLAYBACK_COMPLETE: {
+        songId: string;
+    };
+    PLAYBACK_NEXT: {
+        songId: string;
+    };
+    PLAYBACK_PREVIOUS: {
+        songId: string;
+    };
+    EQUALIZER_CHANGED: {
+        enabled: boolean;
+        preset?: string;
+        bands?: number[];
+    };
+}
+export type PlayerEventType = keyof PlayerEvents;
+export interface AudioFocusConfig {
+    focusGain: number;
+    willPauseWhenDucked: boolean;
+}

package/lib/types/player.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/types/scanner.types.d.ts

@@ -0,0 +1,29 @@
+export interface ScannerEvents {
+    SCAN_PROGRESS: {
+        processed: number;
+        total: number;
+        percentage: number;
+    };
+    SCAN_COMPLETE: {
+        totalSongs: number;
+        scanPaths: string[];
+    };
+    FILE_ADDED: {
+        songId: string;
+        path: string;
+        song: any;
+    };
+    FILE_DELETED: {
+        songId: string;
+        path: string;
+    };
+    PERMISSION_STATUS: {
+        granted: boolean;
+        message: string;
+    };
+}
+export type ScannerEventType = keyof ScannerEvents;
+export interface ScanResult {
+    totalSongs: number;
+    scanPaths: string[];
+}

package/lib/types/scanner.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils/constants.d.ts

@@ -0,0 +1,31 @@
+export declare const ScannerEvents: {
+    readonly SCAN_PROGRESS: "SCAN_PROGRESS";
+    readonly SCAN_COMPLETE: "SCAN_COMPLETE";
+    readonly FILE_ADDED: "FILE_ADDED";
+    readonly FILE_DELETED: "FILE_DELETED";
+    readonly PERMISSION_STATUS: "PERMISSION_STATUS";
+};
+export declare const PlayerEvents: {
+    readonly PLAYBACK_STATE_CHANGED: "PLAYBACK_STATE_CHANGED";
+    readonly PLAYBACK_QUEUE_CHANGED: "PLAYBACK_QUEUE_CHANGED";
+    readonly PLAYBACK_ERROR: "PLAYBACK_ERROR";
+    readonly PLAYBACK_COMPLETE: "PLAYBACK_COMPLETE";
+    readonly PLAYBACK_NEXT: "PLAYBACK_NEXT";
+    readonly PLAYBACK_PREVIOUS: "PLAYBACK_PREVIOUS";
+    readonly EQUALIZER_CHANGED: "EQUALIZER_CHANGED";
+};
+export declare const RepeatMode: {
+    readonly NONE: "none";
+    readonly ONE: "one";
+    readonly ALL: "all";
+};
+export declare const EqualizerPresets: {
+    readonly NORMAL: "normal";
+    readonly ROCK: "rock";
+    readonly POP: "pop";
+    readonly JAZZ: "jazz";
+    readonly CLASSIC: "classic";
+    readonly DANCE: "dance";
+    readonly FLAT: "flat";
+};
+export declare const AudioExtensions: string[];

package/lib/utils/constants.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AudioExtensions = exports.EqualizerPresets = exports.RepeatMode = exports.PlayerEvents = exports.ScannerEvents = void 0;
+exports.ScannerEvents = {
+    SCAN_PROGRESS: 'SCAN_PROGRESS',
+    SCAN_COMPLETE: 'SCAN_COMPLETE',
+    FILE_ADDED: 'FILE_ADDED',
+    FILE_DELETED: 'FILE_DELETED',
+    PERMISSION_STATUS: 'PERMISSION_STATUS',
+};
+exports.PlayerEvents = {
+    PLAYBACK_STATE_CHANGED: 'PLAYBACK_STATE_CHANGED',
+    PLAYBACK_QUEUE_CHANGED: 'PLAYBACK_QUEUE_CHANGED',
+    PLAYBACK_ERROR: 'PLAYBACK_ERROR',
+    PLAYBACK_COMPLETE: 'PLAYBACK_COMPLETE',
+    PLAYBACK_NEXT: 'PLAYBACK_NEXT',
+    PLAYBACK_PREVIOUS: 'PLAYBACK_PREVIOUS',
+    EQUALIZER_CHANGED: 'EQUALIZER_CHANGED',
+};
+exports.RepeatMode = {
+    NONE: 'none',
+    ONE: 'one',
+    ALL: 'all',
+};
+exports.EqualizerPresets = {
+    NORMAL: 'normal',
+    ROCK: 'rock',
+    POP: 'pop',
+    JAZZ: 'jazz',
+    CLASSIC: 'classic',
+    DANCE: 'dance',
+    FLAT: 'flat',
+};
+exports.AudioExtensions = [
+    '.mp3',
+    '.mp4',
+    '.m4a',
+    '.aac',
+    '.flac',
+    '.wav',
+    '.ogg',
+    '.opus',
+    '.wma',
+    '.amr',
+    '.aif',
+    '.aiff',
+    '.mid',
+    '.midi',
+    '.xmf',
+    '.mxmf',
+    '.rtttl',
+    '.rtx',
+    '.ota',
+    '.imy',
+];

package/lib/utils/events.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "react-native-mp3",
+  "version": "0.1.0",
+  "description": "A comprehensive music player for React Native with offline/online playback, file scanning, metadata extraction, and background playback",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "react-native": "src/index.ts",
+  "source": "src/index.ts",
+  "files": [
+    "src",
+    "android",
+    "lib",
+    "!**/__tests__",
+    "!**/__fixtures__",
+    "!**/__mocks__",
+    "!example"
+  ],
+  "scripts": {
+    "prepare": "npm run build",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "lint": "eslint src --ext .ts,.tsx",
+    "prepack": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "react-native",
+    "android",
+    "music",
+    "player",
+    "mp3",
+    "audio",
+    "scanner",
+    "metadata"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/RakeshPrasad28/react-native-mp3.git"
+  },
+  "author": "Rakesh",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/yourusername/react-native-mp3/issues"
+  },
+  "homepage": "https://github.com/yourusername/react-native-mp3#readme",
+  "peerDependencies": {
+    "react": ">=16.8.0",
+    "react-native": ">=0.60.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "@types/react-native": "^0.70.0",
+    "typescript": "^4.9.0",
+    "@react-native-community/eslint-config": "^3.2.0",
+    "eslint": "^8.0.0",
+    "react": "18.2.0",
+    "react-native": "0.72.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}