build universal cross-platform apps with react native
Quick Start β’ Features β’ Platforms β’ Templates β’ Plugins β’ Integrations β’ Configurations β’ Architecture β’ Project Config β’ App Configs β’ Build Hooks β’ CLI β’ ReNative CLI β’ Developing ReNative Locally β’ Runtime β’ Contributing β’ Discussions β’ Contributors β’ Backers β’ Sponsors β’ Community β’ Stats β’ License
iOS |
tvOS |
Android TV |
macOS |
---|---|---|---|
Android |
Web |
Tizen TV |
LG webOS |
FirefoxOS |
Windows |
Firefox TV |
KaiOS |
Tizen Mobile |
Tizen Watch |
Android Wear | ... |
... |
The universal development SDK to build multi-platform projects with react native. Includes latest
iOS
,tvOS
,Android
,Android TV
,Web
,Tizen TV
,Tizen Watch
,LG webOS
,macOS/OSX
,Windows
,KaiOS
,Firefox OS
andFirefox TV
platforms
- Ideal starting point for advanced multi-platform projects.
- Uses latest vanilla native project templates including Xcode with Swift and Android with Kotlin support
- Includes bleeding edge dependencies configured to work with each other
$ npm install rnv -g
$ rnv new
Follow steps in the terminal
3) Create 3 separate terminal tabs/windows. use one to keep bundler running and other one for build commands
TAB 1:
Start the bundler
$ rnv start
TAB 2:
Run your first ios
app
$ rnv run -p ios
TAB 3:
Run your first web
app
$ rnv run -p web
open: http://0.0.0.0:8080/
π Congratulations! You're now multi-platform developer!
π
All app code is located in ./src
directory
Build app blazingly fast with built-in features:
- Standard react-native community plugins
- React-Navigation Support
- Embedded 0 configuration custom font support
- SVG Icon Support
- Hot-reload development / debugging
- Deployment Ready project
- Generated projects can be opened and profiled in standard IDEs like Xcode, Android Studio, Tizen IDE etc
- Node
10.13.0
or newer - NPM
6.4.1
or newer - Android Studio (if you want to develop for Android)
- Xcode (if you want to develop for iOS/tvOS)
- Tizen Studio (if you want to develop for Tizen)
- WebOS SDK (if you want to develop for WebOS)
- KaiOS SDK (if you want to develop for KaiOS)
Hello World:
https://www.npmjs.com/package/renative-template-hello-world
Blank:
https://www.npmjs.com/package/renative-template-blank
Chat App:
https://www.npmjs.com/package/@reactseals/renative-template-chat
ReNative Supports standard community driven react-native plugins you can use to enhance the functionality of your apps:
Get list of all available community plugins. (NOTE you can always add new one manually into projectConfig/plugins.json
)
rnv plugin list
you should get colorised overview similar to this:
add new plugin to your project:
rnv plugin add
and follow the command prompt steps
Update your current plugins with latest ones from ReNative
rnv plugin update
and follow the command prompt steps
You can configure multiple React Native plugins without need to update project blueprints.
default location of plugin configs is ./projectConfig/plugins.json
Example:
{
"plugins": {
"renative": "source:rnv",
"react": "source:rnv",
"react-art": "source:rnv",
"react-dom": "source:rnv",
"react-native": "source:rnv",
"react-native-web": "source:rnv",
"react-native-web-image-loader": "source:rnv",
"react-native-gesture-handler": "source:rnv",
"react-navigation": "source:rnv",
"react-navigation-tabs": "source:rnv",
"react-native-reanimated": "source:rnv",
"react-native-vector-icons": "source:rnv"
}
}
You can also customise default plugin configuration:
{
"plugins": {
"react-native-gesture-handler": {
"version": "0.1.0",
"ios": {
"podName": "RNGestureHandler",
"path": "node_modules/react-native-gesture-handler"
},
"android": {
"package": "com.swmansion.gesturehandler.react.RNGestureHandlerPackage",
"path": "node_modules/react-native-gesture-handler/android"
}
}
}
}
Plugin Spec:
{
"pugin-name": {
"version": "",
"enabled": true,
"ios": {},
"android": {},
"webpack": {
"modulePaths": [],
"moduleAliases": []
}
}
}
./projectConfig
folder is used to configure your project properties which can be used in appConfigs / buildFlavours
.
βββ projectConfig # Project configuration files/assets
βββ fonts # Folder for all custom fonts
βββ fonts.json # Fonts configuration
βββ permissions.json # Permissions configuration
βββ plugins.json # React Native Plugins configuration
./appConfigs
offers powerful configuration system which allows you to configure various flavours in your projects.
./appConfigs/APP_ID/config.json
spec:
{
"id": "APP_ID",
"common": {
"title": "",
"description": "",
"author": {
"name": ""
},
"includedPlugins": ["*"],
"includedFonts": ["*"]
},
"platforms": {
}
}
Re-Generate platform projects (for helloWorld app config platforms):
rnv platform configure -c helloWorld
Configure your multi-platform app based on ./appConfigs/helloWorld
configuration:
rnv app configure -c helloWorld -u
Applies for android
, androidtv
, androidwear
For appConfigs:
{
"entryFile": "",
"universalApk": true,
"multipleAPKs": false,
"minSdkVersion": 21,
"backgroundColor": "",
"id": "",
"signingConfig": "",
"bundleAssets": false,
"permissions": [],
"bundleAssets": true,
"bundleIsDev": true,
"buildSchemes": {}
}
For plugins:
{
"package": "",
"path": "",
"AndroidManifest": {},
"BuildGradle": {},
"AppBuildGradle": {}
}
Applies for ios
, tvos
For appConfigs:
{
"entryFile": "",
"backgroundColor": "",
"id": "",
"bundleAssets": false,
"permissions": [],
"bundleAssets": true,
"bundleIsDev": true,
"teamID": "",
"scheme": "",
"permissions": ["*"],
"orientationSupport": {
"phone": [
"UIInterfaceOrientationPortrait",
"UIInterfaceOrientationPortraitUpsideDown",
"UIInterfaceOrientationLandscapeLeft",
"UIInterfaceOrientationLandscapeRight"
],
"tab": [
"UIInterfaceOrientationPortrait",
"UIInterfaceOrientationPortraitUpsideDown",
"UIInterfaceOrientationLandscapeLeft",
"UIInterfaceOrientationLandscapeRight"
]
},
"provisioningStyle": "",
"systemCapabilities": {},
"entitlements": {},
"buildSchemes": {}
}
For plugins:
{
"podName": "",
"path": "",
"appDelegateApplicationMethods": {
"didFinishLaunchingWithOptions": [],
"open": [],
"supportedInterfaceOrientationsFor": [],
"didReceiveRemoteNotification": [],
"didFailToRegisterForRemoteNotificationsWithError": [],
"didReceive": [],
"didRegister": [],
"didRegisterForRemoteNotificationsWithDeviceToken": [],
}
}
Applies for web
{
"id": "",
"entryFile": "",
"title": "",
"webpackConfig": {
"devServerHost": "",
"customScripts": []
},
"buildSchemes": {}
}
rnv
will create config folder at this location: ~/.rnv/config.json
Open the file and edit SDK paths of platforms you plan to use:
{
"sdks": {
"ANDROID_SDK": "/Users/<USER>/Library/Android/sdk",
"ANDROID_NDK": "/Users/<USER>/Library/Android/sdk/ndk-bundle",
"IOS_SDK": "No need. Just install Xcode",
"TIZEN_SDK": "/Users/<USER>/tizen-studio",
"WEBOS_SDK": "/Users/<USER>/Library/webOS_TV_SDK",
"KAIOS_SDK": "/Applications/Kaiosrt.app"
}
}
You can also edit your preferred emulator targets (allows you to run rnv target launch -p <PLATFORM>
without -p <TARGET>
)
{
"defaultTargets": {
"android": "Nexus_5X_API_26",
"androidtv": "Android_TV_720p_API_22",
"androidwear": "Android_Wear_Round_API_28",
"ios": "iPhone 6",
"tvos": "Apple TV 4K",
"tizen": "T-samsung-5.0-x86",
"tizenwatch": "W-5.0-circle-x86",
"webos": "emulator"
}
}
For Android release signing, ReNative creates ~/GLOBAL_RNV/PROJECT_NAME/APP_CONFIG_ID/config.private.json
file
with path to your release keystore file and its credentials.
{
"android": {
"storeFile": "./release.keystore",
"storePassword": "************",
"keyAlias": "************",
"keyPassword": "************"
}
}
Then you can run the release app by:
rnv app configure -p android
rnv run -p android -s release
You can configure different app ID, Title etc. with buildScheme field in you appConfig file.
Example:
"buildSchemes": {
"debug": {
"id": "renative.helloworld.debug",
"runScheme": "Debug",
"bundleAssets": false,
"bundleIsDev": true
},
"release": {
"id": "renative.helloworld.release",
"runScheme": "Release",
"bundleAssets": true,
"bundleIsDev": false
}
}
this will allow you to build 2 separate iOS apps with slightly different configurations:
rnv run -p ios -s debug
(-s debug
is DEFAULT option so you don't have to add it every time)
and
rnv run -p ios -s release
Sometimes you need to add buildFlavour specific file into project before build. ie Firebase, Crashlytics configs and so on
you can achieve by creating folder with postfix <PLATFORM>@<BUILD_SCHEME_NAME>
.
βββ appConfigs
βββ helloWorld
βββ assets
βββ plugins
β βββ some-plugin
β βββ builds
β βββ android@release
β β βββ fileToBeInjectedInReleaseMode.txt
β βββ android@debug
β βββ fileToBeInjectedInDebugMode.txt
βββ builds
βββ android@release
β βββ fileToBeInjectedInReleaseMode.txt
βββ android@debug
βββ fileToBeInjectedInDebugMode.txt
For decoupled project you might need to point to custom appConfig location per project. because that location might be different for each developer you can create rnv-config.local.json
in your project root (git ignored by default) which points to your local appConfig folder.
Contents of the file should follow this format:
{
"appConfigsPath": "/Users/<USER>/my-local-app-config-folder"
}
Sometimes you need to extend CLI functionality with custom build scripts. ReNative makes this easy for you.
create file: ./buildHooks/src/index.js
with this script (NOTE: every top-level method must return Promise):
import chalk from 'chalk';
const hooks = {
hello: c =>
new Promise((resolve, reject) => {
console.log(`\n${chalk.yellow('HELLO FROM BUILD HOOKS!')}\n`);
resolve();
}),
};
const pipes = {};
export { pipes, hooks };
then simply run:
rnv hooks run -x hello
ReNative will transpile and execute it in real time!
index.js
is required entry point but you can create more complex scripts with multiple files/imports.
every top-level method gets invoked with ReNative config
object containing all necessary build information
You can utilize RNV CLI functionality inside of build hooks by simply importing rnv packages:
import {
Constants, Runner, App, Platform, Target, Common, Exec,
PlatformTools, Doctor, PluginTools, SetupTools, FileUtils
} from 'rnv'
Sometimes you want to execute specific hook automatically before/after certain ReNative build phase.
To get list of available hook pipes run:
rnv hooks pipes
You can connect your hook method to one of predefined pipes in your ./buildHooks/src/index.js
:
const pipes = {
'app:configure:before': hooks.hello,
};
Example code above will execute hooks.hello()
before every time you run rnv app configure
commands
const pipes = {
'app:configure:before': [hooks.hello, hooks.someOtherHook],
};
List of available pipe hooks:
'run:before', 'run:after',
'log:before', 'log:after',
'start:before', 'start:after',
'package:before', 'package:after',
'package:before', 'package:after',
'build:before', 'build:after',
'deploy:before', 'deploy:after',
'app:configure:before', 'app:configure:after',
'platform:configure:before', 'platform:configure:after'
List of available config props injected into hooks methods:
//ROOT
c.program;
c.process;
c.command;
c.subCommand;
c.appId;
c.platform;
//FILES
c.files.projectConfig;
c.files.rnvPackage;
//PATHS
c.paths.rnvRootFolder;
c.paths.rnvHomeFolder;
c.paths.rnvPlatformTemplatesFolder;
c.paths.rnvPluginTemplatesFolder;
c.paths.rnvPluginTemplatesConfigPath;
c.paths.rnvPackagePath;
c.paths.rnvPluginsFolder;
c.paths.projectRootFolder;
c.paths.buildHooksFolder;
c.paths.buildHooksDistFolder;
c.paths.buildHooksIndexPath;
c.paths.buildHooksDistIndexPath;
c.paths.projectSourceFolder;
c.paths.projectNpmLinkPolyfillPath;
c.paths.homeFolder;
c.paths.globalConfigFolder;
c.paths.globalConfigPath;
c.paths.projectConfigPath;
c.paths.projectConfigLocalPath;
c.paths.projectPackagePath;
c.paths.rnCliConfigPath;
c.paths.babelConfigPath;
c.paths.projectConfigFolder;
c.paths.projectPluginsFolder;
c.paths.globalConfigFolder;
c.paths.globalConfigPath;
c.paths.appConfigsFolder;
c.paths.entryFolder;
c.paths.platformTemplatesFolders;
c.paths.platformAssetsFolder;
c.paths.platformBuildsFolder;
c.paths.projectPluginsFolder;
c.paths.rnvNodeModulesFolder;
c.paths.projectNodeModulesFolder;
c.paths.runtimeConfigPath;
c.paths.projectConfigFolder;
c.paths.pluginConfigPath;
c.paths.permissionsConfigPath;
c.paths.fontsConfigFolder;
ReNative provides runtime SDK library to support multiplatform development
import { Api } from 'renative'
Build Process
Folder Structure (Generated Project)
.
βββ appConfigs # Application flavour configuration files/assets
β βββ helloWorld # Example application flavour
β βββ assets # Platform assets injected to `./platformAssets`
β βββ builds # Platform files injected to `./platformBuilds`
β βββ config.json # Application flavour config
βββ platformAssets # Generated cross-platform assets
βββ platformBuilds # Generated platform app projects
βββ projectConfig # Project configuration files/assets
β βββ fonts # Folder for all custom fonts
β βββ fonts.json # Fonts configuration
β βββ permissions.json # Permissions configuration
β βββ plugins.json # React Native Plugins configuration
βββ src # Source files
ReNative support flexible override mechanism which allows you customise your project to great degree
./appConfigs/APP_ID/config.json
RULES:
There are 3 levels of override entry objects for your props to fine-tune your app config:
.common
//Applies for all platforms + all schemes.platforms.YOUR_PLATFORM
//Applies specific platforms + all schemes.platforms.YOUR_PLATFORM.buildSchemes.YOUR_SCHEME
//Applies for specific platform + specific scheme
Example:
{
"common": {
"MY_PROP": "Value1"
},
"platforms": {
"ios": {
"MY_PROP": "Value2 overrides Value1",
"buildSchemes": {
"debug": {
"MY_PROP": "Value3 overrides Value 2"
}
}
}
}
}
Override Rules for json props:
Strings
=> Replaced
Numbers
=> Replaced
Arrays
=> Replaced
Objects
=> Merged by top level (not deep merge)
Will be overridden by: https://github.com/pavjacko/renative/blob/master/packages/renative-template-hello-world/appConfigs/helloWorld/config.json#L59
This allows you to configure and build large number of flavoured builds with almost no extra configuration
- Latest swift based Xcode project
- Cocoapods Workspace ready
- Swift 4.1 Support
Feature | Version |
---|---|
Swift | 4.1 |
Deployment Target | 11.4 |
rnv start
rnv run -p ios
IMPORTANT: before you run ReNative app on the actual iOS device you MUST:
- Have ios device connected on the same network as your dev machine
- Have ios developer account properly configured with ability to generate provisioning profiles dynamically (Dynamic Signing)
- Have correct TeamID assigned
..platforms.ios.teamID
in your./appConfigs/<YOUR_APP_CONFIG>/config.json
You can configure each buldScheme
ie -s release
in your config file ./appConfigs/<YOUR_APP_CONFIG>/config.json
rnv start
rnv run -p ios -d
This will run production version on your device (not connected to metro bundler) Same prerequisite as above applies here
rnv start
rnv run -p ios -s release -d
Clean and Re-build platform project
rnv run -p ios -r
Launch app with specific iOS simulator
rnv run -p ios -t "iPhone 6 Plus"
Launch app with specific iOS simulator (let ReNative to give you the list of available options):
rnv run -p ios -t ?
Launch specific emulator :
rnv target launch -p ios -t "iPhone 8"
Launch specific emulator (let ReNative to give you the list of available options):
rnv target launch -p ios -t ?
Get list of all available devices
rnv target list -p ios
Get device/simulator logs
rnv log -p ios
Get device/simulator logs with filter
rnv log -p ios -f com.myapp
- Latest Android project
- Kotlin Support
- Support for Gradle 4.9
- Android Studio for Android development
- Android SDK
23.0.1
or newer for Android development
Feature | Version |
---|---|
Gradle | 4.10.1 |
Android Gradle | 3.3.1 |
Kotlin | 1.3.20 |
Target SDK | 27 |
You can create variety of emulators via Android Studio IDE
NOTE: make sure you have 1 android device connected or 1 emulator running
rnv start
rnv run -p android
rnv start
rnv run -p android -d
This will run production version on your device (not connected to metro bundler)
You can configure each buldScheme
ie -s release
in your config file ./appConfigs/<YOUR_APP_CONFIG>/config.json
rnv start
rnv run -p android -s release -d
Clean and Re-build platform project
rnv run -p android -r
Launch specific android emulator:
rnv target launch -p android -t Nexus_5X_API_26
Launch app with specific iOS simulator (let ReNative to give you the list of available options):
rnv run -p android -t ?
Launch specific emulator :
rnv target launch -p android -t Nexus_5X_API_26
Launch specific emulator (let ReNative to give you the list of available options):
rnv target launch -p android -t ?
Get list of all available devices
rnv target list -p android
Get device/simulator logs
rnv log -p android
Get device/simulator logs with filter
rnv log -p android -f com.myapp
- Latest swift based Xcode project
- Cocoapods Workspace ready
- Swift 4.1 Support
Feature | Version |
---|---|
Swift | 4.1 |
Deployment Target | 11.4 |
rnv start
rnv run -p tvos
Clean and Re-build platform project
rnv run -p tvos -r
Launch with specific tvOS simulator
rnv run -p tvos -t "Apple TV 4K"
- Latest Android project
- Kotlin Support
- Support for Gradle 4.9
- Android Studio for Android development
- Android SDK
23.0.1
or newer for Android development
Feature | Version |
---|---|
Gradle | 4.10.1 |
Android Gradle | 3.3.1 |
Kotlin | 1.3.20 |
Target SDK | 27 |
NOTE: make sure you have 1 android device connected or 1 emulator running
rnv start
rnv run -p androidtv
Clean and Re-build platform project
rnv run -p androidtv -r
Launch specific emulator:
rnv target launch -p androidtv -t Android_TV_720p_API_22
- Supports Chrome, Safari, Firefox, IE10+
- no extra requirements required
Feature | Version |
---|---|
Webpack | 3.11.0 |
react-native-web | 0.9.1 |
Babel Core | 7.1.2 |
rnv run -p web
RNV will run local server and attempt to open browser URL: http://0.0.0.0:8080/
If you only want to run server:
rnv start -p web
rnv build -p web
your deployable web app folder will be located in ./platformBuilds/<APP_ID>_web/public
Clean and Re-build platform project
rnv run -p web -r
Run with verbose logging:
rnv run -p web --info
Run app on custom port 9999
:
rnv run -p web --port 9999
- Latest Tizen project
- Support for Tizen 5.0, 4.0, 3.0
- Tizen SDK
5.0
- Make sure your CPU supports virtualization. Otherwise Tizen emulator might not start.
- If you are deploying to a TV, follow this guide to set your TV in developer mode Link
Feature | Version |
---|---|
Tizen Studio | 2.5 |
Tizen SDK | 5.0 |
react-native-web | 0.9.9 |
Babel Core | 7.1.2 |
Make sure you have at least 1 TV VM setup
rnv target launch -p tizen -t T-samsung-5.0-x86
rnv run -p tizen
Clean and Re-build platform project
rnv run -p tizen -r
Launch with specific Tizen simulator:
rnv run -p tizen -t T-samsung-5.0-x86
- Latest Tizen project
- Support for Tizen 5.0
- Tizen SDK
5.0
Feature | Version |
---|---|
Tizen Studio | 2.5 |
Tizen SDK | 5.0 |
react-native-web | 0.9.9 |
Babel Core | 7.1.2 |
Make sure you have at least 1 TV VM setup
rnv target launch -p tizenwatch -t W-5.0-circle-x86
rnv run -p tizenwatch
Clean and Re-build platform project
rnv run -p tizenwatch -r
Launch with specific Tizen Watch simulator:
rnv run -p tizenwatch -t W-5.0-circle-x86
- Latest LG webOS Project
- LG Emulator v3.0.0
Feature | Version |
---|---|
react-native-web | 0.9.9 |
Babel Core | 7.1.2 |
- launch webOS emulator via CLI
rnv target launch -p webos -t emulator
- launch webOS emulator Manually
usually located in something like:
<USER_PATH>/Library/webOS_TV_SDK/Emulator/v4.0.0/LG_webOS_TV_Emulator_RCU.app
rnv run -p webos
- Latest Tizen project
- Support for Tizen 5.0, 4.0, 3.0
- Tizen SDK
5.0
- Make sure your CPU supports virtualization. Otherwise Tizen emulator might not start.
- If you are deploying to a TV, follow this guide to set your TV in developer mode Link
Feature | Version |
---|---|
Tizen Studio | 2.5 |
Tizen SDK | 5.0 |
react-native-web | 0.9.9 |
Babel Core | 7.1.2 |
Make sure you have at least 1 TV VM setup
rnv target launch -p tizenmobile -t M-5.0-x86
rnv run -p tizenmobile
Clean and Re-build platform project
rnv run -p tizenmobile -r
Launch with specific Tizen simulator:
rnv run -p tizenmobile -t M-5.0-x86
- support for OSX/macOS
- Based on Electron
- n/a
Feature | Version |
---|---|
electron | 2.0.0 |
react-native-web | 0.9.9 |
electron-builder | 20.28.2 |
rnv run -p macos
This will run production version on your simulator (not connected to devserver)
You can configure each buldScheme
ie -s release
in your config file ./appConfigs/<YOUR_APP_CONFIG>/config.json
rnv run -p macos -s release
rnv export -p macos -s release
- support for Windows 10+
- Based on Electron
- Windows dev environment
Feature | Version |
---|---|
electron | 2.0.0 |
react-native-web | 0.9.1 |
electron-builder | 20.28.2 |
rnv run -p windows
- Latest Android project
- Kotlin Support
- Support for Gradle 4.9
- Android Studio for Android development
- Android SDK
23.0.1
or newer for Android development
Feature | Version |
---|---|
Gradle | 4.10.1 |
Android Gradle | 3.3.1 |
Kotlin | 1.3.20 |
Target SDK | 27 |
NOTE: make sure you have 1 android wear device connected or 1 wear emulator running
rnv run -p androidwear
NOTE: There is a bug in RN. for now you must NOT have running bundler (rnv start
) in order for wear sim to work
Clean and Re-build platform project
rnv run -p androidwear -r
Launch specific emulator:
rnv target launch -p androidwear -t Android_Wear_Round_API_28
- KaiOSrt for emulator
After installation you can launch it via Applications:
NOTE: make sure you have 1 android wear device connected or 1 wear emulator running
rnv run -p kaios
- FirefoxDeveloperEdition for IDE + Emulator
After installation you can launch it via Applications:
Tools -> Web Developer -> WebIDE
NOTE: make sure you have 1 android wear device connected or 1 wear emulator running
rnv run -p firefoxos
- FirefoxDeveloperEdition for IDE + Emulator
After installation you can launch it via Applications:
Tools -> Web Developer -> WebIDE
NOTE: make sure you have 1 android wear device connected or 1 wear emulator running
rnv run -p firefoxtv
Deployed to https://www.npmjs.com/package/rnv
Commands:
rnv //Print help
rnv --version //Print ReNative Version
rnv run -p <PLATFORM> //Run app on simulator/device/browser
rnv target launch -p <PLATFORM> //Start target (i.e. simulator/ emulator)
rnv app configure //Configure app based on selected appConfig (copy runtime, initialise, copy assets, versions)
rnv new //Create new app
rnv platform eject //Eject platformTemplates into project
rnv platform connect //Use ReNative predefined templates
Get basic info about your current project
rnv status
This will delete all node-modules
and package-lock.json
files. you will be asked to confirm this action
rnv clean
ReNative Allows you to perform reset commands if you facing unforeseen problems or migrating ReNative versions
Reset Metro Bundler cache
rnv start -r
Reset specific platform of platformBuild project (fully recreate project based on provided template)
rnv run -p <PLATFORM> -r
rnv app configure -p <PLATFORM> -r
Reset all platforms of platformBuild project (fully recreate projects based on provided template)
rnv app configure -r
If you prefer having your logs clean (without color decorations). you can use --mono
flag for anyrnv
command.
This is particularly useful for CI where logs are usually stripped from colors by CI logger and producing visual artefacts
Examples:
rnv status --mono
rnv start --mono
...
By default, ReNative controls platformTemplates for you. Advantage is that you don't need to maintain them and will get all the updates automatically. If however you need to customise them you can eject them directly into your project.
rnv platform eject
your projects will be build using ./platformTemplates
from this point
If you want to revert back to using ReNative templates simply run
rnv platform connect
your projects will be build using ./node_modules/renative/rnv-cli/platformTemplates
from this point
If you need full control over whole ReNative build you can clone and develop it locally
1) clone [email protected]:pavjacko/renative.git
2) cd renative
3) npm i
4) npm run watch
5) npm run link
At this point your global $ rnv
command is linked directly into project above.
It's also best way to contribute back to RNV! :)
rnv template apply
=> pick renative-template-hello-world
https://spectrum.chat/renative
This project exists thanks to all the people who contribute. [Contribute].
Thank you to all our backers! π [Become a backer]
Special thanks to open-source initiatives this project utilises, notably:
- https://www.npmjs.com/package/react-native
- https://www.npmjs.com/package/react-native-web
- https://www.npmjs.com/package/webpack
- https://www.npmjs.com/package/babel-cli
- https://www.npmjs.com/package/electron