Error When Trying to Upload File(S) to Hockeyapp: 404-
Sign upwards With App Center to use CodePush
React Native Module for CodePush
Note: This README is only relevant to the latest version of our plugin. If y'all are using an older version, delight switch to the relevant tag on our GitHub repo to view the docs for that particular version.
This plugin provides client-side integration for the CodePush service, assuasive you to easily add a dynamic update experience to your React Native app(south).
- How does it work?
- Supported React Native Platforms
- Supported Components
- Getting Started
- iOS Setup
- Android Setup
- Windows Setup
- Plugin Usage
- Shop Guideline Compliance
- Releasing Updates
- Multi-Deployment Testing
- Android
- iOS
- Dynamic Deployment Assignment
- API Reference
- JavaScript API
- Objective-C API Reference (iOS)
- Java API Reference (Android)
- Debugging / Troubleshooting
- Case Apps / Starters
- Continuous Integration / Delivery
- TypeScript Consumption
How does information technology work?
A React Native app is composed of JavaScript files and any accompanying images, which are bundled together by the metro bundler and distributed as part of a platform-specific binary (i.e. an .ipa or .apk file). Once the app is released, updating either the JavaScript code (e.thousand. making bug fixes, adding new features) or image assets, requires yous to recompile and redistribute the unabridged binary, which of grade, includes whatever review fourth dimension associated with the shop(south) you are publishing to.
The CodePush plugin helps get product improvements in front of your stop users instantly, by keeping your JavaScript and images synchronized with updates you release to the CodePush server. This manner, your app gets the benefits of an offline mobile experience, as well as the "spider web-like" agility of side-loading updates as soon equally they are available. It's a win-win!
In lodge to ensure that your end users always have a functioning version of your app, the CodePush plugin maintains a copy of the previous update, so that in the outcome that you accidentally button an update which includes a crash, information technology can automatically roll back. This fashion, you can rest assured that your newfound release agility won't result in users becoming blocked before yous accept a chance to gyre back on the server. Information technology's a win-win-win!
Note: Whatsoever product changes which impact native lawmaking (e.m. modifying your AppDelegate.m/MainActivity.java file, adding a new plugin) cannot exist distributed via CodePush, and therefore, must exist updated via the advisable store(s).
Supported React Native platforms
- iOS (seven+)
- Android (4.i+) on TLS 1.2 uniform devices
- Windows (UWP)
Nosotros try our best to maintain backwards compatibility of our plugin with previous versions of React Native, but due to the nature of the platform, and the beingness of breaking changes betwixt releases, information technology is possible that you need to use a specific version of the CodePush plugin in order to support the verbal version of React Native you lot are using. The following table outlines which CodePush plugin versions officially support the respective React Native versions:
| React Native version(southward) | Supporting CodePush version(s) |
|---|---|
| <0.14 | Unsupported |
| v0.14 | v1.3 (introduced Android support) |
| v0.15-v0.18 | v1.4-v1.6 (introduced iOS asset back up) |
| v0.19-v0.28 | v1.seven-v1.17 (introduced Android asset back up) |
| v0.29-v0.30 | v1.thirteen-v1.17 (RN refactored native hosting code) |
| v0.31-v0.33 | v1.14.half-dozen-v1.17 (RN refactored native hosting code) |
| v0.34-v0.35 | v1.15-v1.17 (RN refactored native hosting code) |
| v0.36-v0.39 | v1.16-v1.17 (RN refactored resume handler) |
| v0.40-v0.42 | v1.17 (RN refactored iOS header files) |
| v0.43-v0.44 | v2.0+ (RN refactored uimanager dependencies) |
| v0.45 | v3.0+ (RN refactored instance manager code) |
| v0.46 | v4.0+ (RN refactored js bundle loader lawmaking) |
| v0.46-v0.53 | v5.1+ (RN removed unused registration of JS modules) |
| v0.54-v0.55 | v5.3+ (Android Gradle Plugin 3.x integration) |
| v0.56-v0.58 | v5.four+ (RN upgraded versions for Android tools) |
| v0.59 | v5.six+ (RN refactored js bundle loader code) |
| v0.lx-v0.61 | v6.0+ (RN migrated to Autolinking) |
| v0.62-v0.64 | v6.2+ (RN removed LiveReload) |
| v0.65 | v7.2+ (RN updated iPhone-target-version) |
NOTE: react-native-code-push versions lower than v5.seven.0 will terminate working in the near time to come. Y'all can find more information in our documentation.
We work hard to reply to new RN releases, but they do occasionally pause us. We will update this nautical chart with each RN release, and so that users can bank check to see what our "official" back up is.
Supported Components
When using the React Native assets arrangement (i.due east. using the require("./foo.png") syntax), the following listing represents the set of core components (and props) that support having their referenced images and videos updated via CodePush:
| Component | Prop(s) |
|---|---|
Image | source |
MapView.Marker (Requires react-native-maps >=O.three.2) | paradigm |
ProgressViewIOS | progressImage, trackImage |
TabBarIOS.Item | icon, selectedIcon |
ToolbarAndroid (React Native 0.21.0+) | deportment[].icon, logo, overflowIcon |
Video | source |
The following listing represents the prepare of components (and props) that don't currently support their assets beingness updated via CodePush, due to their dependency on static images and videos (i.due east. using the { uri: "foo" } syntax):
| Component | Prop(south) |
|---|---|
SliderIOS | maximumTrackImage, minimumTrackImage, thumbImage, trackImage |
Video | source |
As new core components are released, which back up referencing assets, we'll update this list to ensure users know what exactly they can expect to update using CodePush.
Note: CodePush just works with Video components when using require in the source prop. For example:
< Video source = { require ( "./foo.mp4" ) } / > Getting Started
Once you've followed the general-purpose "getting started" instructions for setting up your CodePush account, you can start CodePush-ifying your React Native app by running the following command from within your app's root directory:
npm install --save react-native-code-push button Equally with all other React Native plugins, the integration experience is different for iOS and Android, so perform the following setup steps depending on which platform(s) you are targeting. Annotation, if y'all are targeting both platforms it is recommended to create split CodePush applications for each platform.
If you want to encounter how other projects have integrated with CodePush, you can check out the excellent example apps provided by the community. Additionally, if you'd like to quickly familiarize yourself with CodePush + React Native, you tin bank check out the crawly getting started videos produced past Bilal Budhani and/or Deepak Sisodiya .
Notation: This guide assumes you lot take used the react-native init command to initialize your React Native projection. As of March 2017, the control create-react-native-app can also be used to initialize a React Native projection. If using this control, please run npm run eject in your projection'southward abode directory to go a projection very like to what react-native init would have created.
So continue with installing the native module
- iOS Setup
- Android Setup
- Windows Setup
Plugin Usage
With the CodePush plugin downloaded and linked, and your app request CodePush where to become the correct JS bundle from, the simply thing left is to add together the necessary code to your app to control the post-obit policies:
-
When (and how oft) to check for an update? (for example app start, in response to clicking a push in a settings folio, periodically at some fixed interval)
-
When an update is available, how to present it to the finish user?
The simplest mode to do this is to "CodePush-ify" your app'due south root component. To do then, you can cull 1 of the following two options:
-
Option 1: Wrap your root component with the
codePushcollege-gild component:-
For class component
import codePush from "react-native-code-push" ; class MyApp extends Component { } MyApp = codePush ( MyApp ) ;
-
For functional component
import codePush from "react-native-code-push button" ; let MyApp: ( ) => React$Node = ( ) => { } MyApp = codePush ( MyApp ) ;
-
-
Option 2: Use the ES7 decorator syntax:
NOTE: Decorators are not all the same supported in Babel 6.ten pending proposal update. You may demand to enable it past installing and using boom-boom-preset-react-native-phase-0.
-
For class component
import codePush from "react-native-lawmaking-push" ; @codePush class MyApp extends Component { }
-
For functional component
import codePush from "react-native-code-push" ; const MyApp: ( ) => React$Node = ( ) => { } export default codePush ( MyApp ) ;
-
Past default, CodePush will check for updates on every app kickoff. If an update is bachelor, it will exist silently downloaded, and installed the next time the app is restarted (either explicitly by the end user or past the Bone), which ensures the least invasive experience for your end users. If an available update is mandatory, then it will exist installed immediately, ensuring that the end user gets it as soon as possible.
If you would like your app to find updates more apace, you tin can also choose to sync up with the CodePush server every time the app resumes from the background.
-
For course component
let codePushOptions = { checkFrequency: codePush . CheckFrequency . ON_APP_RESUME } ; class MyApp extends Component { } MyApp = codePush ( codePushOptions ) ( MyApp ) ;
-
For functional component
let codePushOptions = { checkFrequency: codePush . CheckFrequency . ON_APP_RESUME } ; allow MyApp: ( ) => React$Node = ( ) => { } MyApp = codePush ( codePushOptions ) ( MyApp ) ;
Alternatively, if you desire fine-grained control over when the check happens (like a button press or timer interval), you can call CodePush.sync() at any time with your desired SyncOptions, and optionally turn off CodePush's automated checking past specifying a manual checkFrequency:
permit codePushOptions = { checkFrequency: codePush . CheckFrequency . Transmission } ; grade MyApp extends Component { onButtonPress ( ) { codePush . sync ( { updateDialog: truthful , installMode: codePush . InstallMode . IMMEDIATE } ) ; } render ( ) { return ( < View > < TouchableOpacity onPress = { this . onButtonPress } > < Text >Bank check for updates< / Text > < / TouchableOpacity > < / View > ) } } MyApp = codePush ( codePushOptions ) ( MyApp ) ; If you would like to brandish an update confirmation dialog (an "agile install"), configure when an bachelor update is installed (like force an firsthand restart) or customize the update feel in any other manner, refer to the codePush() API reference for data on how to tweak this default behavior.
Notation: If you are using Redux and Redux Saga, yous tin can alternatively use the react-native-code-push-saga module, which allows you to customize when sync is called in a peradventure simpler/more idiomatic way.
Store Guideline Compliance
Android Google Play and iOS App Store have corresponding guidelines that have rules you should be aware of before integrating the CodePush solution within your application.
Google play
Tertiary paragraph of Device and Network Corruption topic describe that updating source lawmaking by whatsoever method other than Google Play'southward update machinery is restricted. But this restriction does not apply to updating javascript bundles.
This restriction does not apply to lawmaking that runs in a virtual car and has express access to Android APIs (such as JavaScript in a webview or browser).
That fully allow CodePush as information technology updates just JS bundles and can't update native code part.
App Store
Paragraph 3.3.2, since back in 2015'southward Apple Developer Program License Understanding fully allowed performing over-the-air updates of JavaScript and assets - and in its latest version (20170605) downloadable here this ruling is even broader:
Interpreted lawmaking may be downloaded to an Application just only so long as such code: (a) does not change the primary purpose of the Application by providing features or functionality that are inconsistent with the intended and advertised purpose of the Application as submitted to the App Store, (b) does not create a shop or storefront for other code or applications, and (c) does not bypass signing, sandbox, or other security features of the OS.
CodePush allows you to follow these rules in total compliance so long as the update yous push does not significantly deviate your product from its original App Store approved intent.
To farther remain in compliance with Apple's guidelines we suggest that App Store-distributed apps don't enable the updateDialog option when calling sync, since in the App Store Review Guidelines it is written that:
Apps must not force users to rate the app, review the app, download other apps, or other like deportment in social club to access functionality, content, or use of the app.
This is not necessarily the case for updateDialog, since it won't forcefulness the user to download the new version, but at to the lowest degree you lot should exist aware of that ruling if y'all make up one's mind to show it.
Releasing Updates
One time your app is configured and distributed to your users, and you lot have made some JS or asset changes, it'south time to release them. The recommended way to release them is using the release-react command in the App Center CLI, which volition bundle your JavaScript files, nugget files, and release the update to the CodePush server.
NOTE: Before you tin start releasing updates, please log into App Center by running the appcenter login command.
In it's the most basic course, this command only requires ane parameter: your owner name + "/" + app proper name.
appcenter codepush release-react -a <ownerName>/<appName> appcenter codepush release-react -a <ownerName>/MyApp-iOS appcenter codepush release-react -a <ownerName>/MyApp-Android The release-react command enables such a simple workflow because it provides many sensible defaults (like generating a release parcel, assuming your app's entry file on iOS is either index.ios.js or index.js). However, all of these defaults tin be customized to allow incremental flexibility equally necessary, which makes information technology a good fit for most scenarios.
# Release a mandatory update with a changelog appcenter codepush release-react -a <ownerName>/MyApp-iOS -m --clarification "Modified the header color" # Release an update for an app that uses a non-standard entry file name, and also capture # the sourcemap file generated past react-native parcel appcenter codepush release-react -a <ownerName>/MyApp-iOS --entry-file MyApp.js --sourcemap-output ../maps/MyApp.map # Release a dev Android build to just 1/4 of your finish users appcenter codepush release-react -a <ownerName>/MyApp-Android --rollout 25 --development true # Release an update that targets users running any one.1.* binary, as opposed to # limiting the update to exact version name in the build.gradle file appcenter codepush release-react -a <ownerName>/MyApp-Android --target-binary-version "~1.one.0" The CodePush client supports differential updates, and so even though you are releasing your JS parcel and assets on every update, your stop users will only actually download the files they need. The service handles this automatically and then that you can focus on creating awesome apps and we tin worry near optimizing end user downloads.
For more details about how the release-react control works, as well as the various parameters information technology exposes, refer to the CLI docs. Additionally, if you would prefer to handle running the react-native bundle command yourself, and therefore, want an fifty-fifty more than flexible solution than release-react, refer to the release command for more details.
If you encounter any problems, or have any questions/comments/feedback, you can ping us inside the #lawmaking-push button aqueduct on Reactiflux, eastward-postal service us and/or check out the troubleshooting details beneath.
NOTE: CodePush updates should be tested in modes other than Debug way. In Debug mode, React Native app always downloads JS packet generated by packager, and so JS bundle downloaded by CodePush does not use.
Multi-Deployment Testing
In our getting started docs, nosotros illustrated how to configure the CodePush plugin using a specific deployment key. However, in order to finer test your releases, information technology is critical that you leverage the Staging and Production deployments that are auto-generated when you showtime created your CodePush app (or any custom deployments yous may accept created). This way, you never release an update to your terminate users that y'all haven't been able to validate yourself.
NOTE: Our customer-side rollback feature can help unblock users afterwards installing a release that resulted in a crash, and server-side rollbacks (i.e. appcenter codepush rollback) let you to preclude boosted users from installing a bad release one time it's been identified. Nevertheless, it's obviously ameliorate if you tin can prevent an erroneous update from being broadly released in the first identify.
Taking advantage of the Staging and Product deployments allows you to attain a workflow like the following (experience costless to customize!):
-
Release a CodePush update to your
Stagingdeployment using theappcenter codepush release-reactcontrol (orappcenter codepush releaseif you need more command) -
Run your staging/beta build of your app, sync the update from the server, and verify it works as expected
-
Promote the tested release from
StagingtoProductionusing theappcenter codepush promotecommand -
Run your production/release build of your app, sync the update from the server and verify it works as expected
Note: If you want to take a more than cautious approach, you can even choose to perform a "staged rollout" as role of #3, which allows you lot to mitigate additional potential chance with the update (like did your testing in #two touch all possible devices/weather?) by just making the production update available to a pct of your users (for example appcenter codepush promote -a <ownerName>/<appName> -s Staging -d Production -r 20). So, subsequently waiting for a reasonable amount of time to see if any crash reports or customer feedback comes in, you can aggrandize it to your entire audience by running appcenter codepush patch -a <ownerName>/<appName> Production -r 100.
You'll notice that the above steps refer to a "staging build" and "product build" of your app. If your build process already generates singled-out binaries per "environment", and then you don't need to read any further, since swapping out CodePush deployment keys is just like handling environment-specific config for any other service your app uses (like Facebook). However, if you lot're looking for examples (including demo projects) on how to setup your build process to suit this, then refer to the following sections, depending on the platform(s) your app is targeting:
- Android
- iOS
Dynamic Deployment Consignment
The higher up section illustrated how you tin leverage multiple CodePush deployments in club to finer exam your updates earlier broadly releasing them to your end users. However, since that workflow statically embeds the deployment assignment into the actual binary, a staging or product build will only ever sync updates from that deployment. In many cases, this is sufficient, since y'all but desire your team, customers, stakeholders, etc. to sync with your pre-production releases, and therefore, simply they need a build that knows how to sync with staging. Even so, if yous want to be able to perform A/B tests, or provide early access of your app to certain users, it tin can prove very useful to be able to dynamically place specific users (or audiences) into specific deployments at runtime.
In order to achieve this kind of workflow, all you demand to practise is specify the deployment key you want the current user to syncronize with when calling the codePush method. When specified, this central will override the "default" ane that was provided in your app's Info.plist (iOS) or MainActivity.coffee (Android) files. This allows you to produce a build for staging or production, that is besides capable of being dynamically "redirected" equally needed.
// Imagine that "userProfile" is a prop that this component received // which includes the deployment key that the current user should utilize. codePush . sync ( { deploymentKey: userProfile . CODEPUSH_KEY } ) ; With that change in place, at present it'south simply a matter of choosing how your app determines the correct deployment central for the current user. In do, in that location are typically two solutions for this:
-
Expose a user-visible mechanism for changing deployments at whatever time. For example, your settings page could have a toggle for enabling "beta" admission. This model works well if yous're non concerned with the privacy of your pre-production updates, and you have power users that may want to opt-in to earlier (and potentially buggy) updates at their ain will (kind of similar Chrome channels). However, this solution puts the decision in the hands of your users, which doesn't help y'all perform A/B tests transparently.
-
Comment the server-side contour of your users with an additional piece of metadata that indicates the deployment they should sync with. By default, your app could merely apply the binary-embedded key, but after a user has authenticated, your server can choose to "redirect" them to a unlike deployment, which allows you to incrementally place certain users or groups in unlike deployments as needed. You could even choose to store the server-response in local storage and so that it becomes the new default. How you store the key alongside your user'due south profiles is entirely up to your authentication solution (for example Auth0, Firebase, custom DB + Rest API), but is generally pretty piffling to exercise.
Annotation: If needed, you could also implement a hybrid solution that allowed your stop-users to toggle between unlike deployments, while also assuasive your server to override that conclusion. This mode, you have a hierarchy of "deployment resolution" that ensures your app has the ability to update itself out-of-the-box, your stop users tin feel rewarded past getting early access to bits, simply you also take the ability to run A/B tests on your users as needed.
Since we recommend using the Staging deployment for pre-release testing of your updates (as explained in the previous section), it doesn't neccessarily make sense to employ it for performing A/B tests on your users, as opposed to assuasive early-access (as explained in selection #1 above). Therefore, we recommend making full use of custom app deployments, and so that you can segment your users notwithstanding makes sense for your needs. For example, you could create long-term or fifty-fifty one-off deployments, release a variant of your app to it, and then identify certain users into it in order to see how they engage.
// #i) Create your new deployment to hold releases of a specific app variant appcenter codepush deployment add together - a < ownerName > /<appName> test-variant-ane // #2) Target whatever new releases at that custom deployment appcenter codepush release - react - a < ownerName > /<appName> -d test-variant-one Notation: The total user count that is reported in your deployment'southward "Install Metrics" volition have into account users that have "switched" from one deployment to another. For example, if your Production deployment currently reports having 1 total user, but you dynamically switch that user to Staging, then the Production deployment would report 0 total users, while Staging would report 1 (the user that only switched). This behavior allows yous to accurately rail your release adoption, even in the event of using a runtime-based deployment redirection solution.
API Reference
- JavaScript API
- Objective-C API Reference (iOS)
- Java API Reference (Android)
Example Apps / Starters
The React Native customs has graciously created some awesome open source apps that can serve equally examples for developers that are getting started. The following is a list of OSS React Native apps that are as well using CodePush, and can therefore exist used to run into how others are using the service:
- F8 App - The official briefing app for F8 2016.
- Feline for Production Hunt - An Android customer for Product Hunt.
- GeoEncoding - An app by Lynx Information technology Digital which demonstrates how to utilise numerous React Native components and modules.
- Math Facts - An app by Khan University to assistance memorize math facts more easily.
Additionally, if you're looking to become started with React Native + CodePush, and are looking for an awesome starter kit, yous should cheque out the following:
- Native Starter Pro
- Pepperoni
Annotation: If you've developed a React Native app using CodePush, that is also open-source, please permit us know. We would love to add together it to this list!
Debugging / Troubleshooting
The sync method includes a lot of diagnostic logging out-of-the-box, and then if you're encountering an issue when using information technology, the all-time thing to try first is examining the output logs of your app. This will tell yous whether the app is configured correctly (similar tin can the plugin discover your deployment key?), if the app is able to reach the server, if an available update is being discovered, if the update is being successfully downloaded/installed, etc. We want to keep improving the logging to be as intuitive/comprehensive every bit possible, so please let us know if yous discover it to exist confusing or missing anything.
The simplest fashion to view these logs is to add the flag --debug for each command. This volition output a log stream that is filtered to just CodePush messages. This makes it piece of cake to identify bug, without needing to use a platform-specific tool, or wade through a potentially high volume of logs.
Additionally, yous can as well use whatever of the platform-specific tools to view the CodePush logs, if you are more than comfortable with them. Simple offset upward the Chrome DevTools Console, the Xcode Console (iOS), the OS Ten Console (iOS) and/or ADB logcat (Android), and look for messages which are prefixed with [CodePush].
Note that by default, React Native logs are disabled on iOS in release builds, and then if you want to view them in a release build, you demand to make the following changes to your AppDelegate.m file:
-
Add an
#import <React/RCTLog.h>statement. For RN < v0.40 use:#import "RCTLog.h" -
Add the following statement to the top of your
application:didFinishLaunchingWithOptionsmethod:RCTSetLogThreshold(RCTLogLevelInfo);
At present you'll be able to meet CodePush logs in either debug or release manner, on both iOS or Android. If examining the logs don't provide an indication of the issue, please refer to the following mutual issues for additional resolution ideas:
| Event / Symptom | Possible Solution |
|---|---|
| Compilation Error | Double-cheque that your version of React Native is compatible with the CodePush version you are using. |
Network timeout / hang when calling sync or checkForUpdate in the iOS Simulator | Try resetting the simulator by selecting the Simulator -> Reset Content and Settings.. carte du jour item, and and then re-running your app. |
Server responds with a 404 when calling sync or checkForUpdate | Double-check that the deployment key you added to your Info.plist (iOS), build.gradle (Android) or that you're passing to sync/checkForUpdate, is in fact right. You lot can run appcenter codepush deployment list <ownerName>/<appName> --displayKeys to view the right keys for your app deployments. |
| Update not beingness discovered | Double-check that the version of your running app (like 1.0.0) matches the version you specified when releasing the update to CodePush. Additionally, make certain that you are releasing to the same deployment that your app is configured to sync with. |
| Update not being displayed after restart | If you're non calling sync on app commencement (like within componentDidMount of your root component), and then you demand to explicitly call notifyApplicationReady on app start, otherwise, the plugin will recollect your update failed and roll it dorsum. |
| I've released an update for iOS simply my Android app also shows an update and information technology breaks it | Be sure yous have dissimilar deployment keys for each platform in guild to receive updates correctly |
| I've released new update merely changes are not reflected | Be sure that yous are running app in modes other than Debug. In Debug mode, React Native app always downloads JS packet generated past packager, so JS bundle downloaded by CodePush does not apply. |
| No JS bundle is being found when running your app confronting the iOS simulator | By default, React Native doesn't generate your JS bundle when running against the simulator. Therefore, if you're using [CodePush bundleURL], and targetting the iOS simulator, you may be getting a nil result. This upshot volition be fixed in RN 0.22.0, just merely for release builds. You can unblock this scenario correct at present by making this modify locally. |
Continuous Integration / Delivery
In addition to being able to use the CodePush CLI to "manually" release updates, we believe that information technology'due south important to create a repeatable and sustainable solution for contiously delivering updates to your app. That way, it's simple plenty for you and/or your squad to create and maintain the rhythm of performing agile deployments. In gild to assist with setting up a CodePush-based CD pipeline, refer to the following integrations with diverse CI servers:
- Visual Studio Team Services - NOTE: VSTS as well has extensions for publishing to HockeyApp and the Google Play shop, so it provides a pretty great mobile CD solution in general.
- Travis CI
Additionally, if y'all'd like more details of what a complete mobile CI/CD workflow can look like, which includes CodePush, check out this first-class article by the ZeeMee engineering team.
TypeScript Consumption
This module ships its *.d.ts file as part of its NPM package, which allows you to simply import information technology, and receive intellisense in supporting editors (similar Visual Studio Code), besides as compile-time type checking if you lot're using TypeScript. For the near part, this beliefs should just work out of the box, however, if you've specified es6 as the value for either the target or module compiler choice in your tsconfig.json file, so just make certain that you also ready the moduleResolution selection to node. This ensures that the TypeScript compiler volition expect within the node_modules for the type definitions of imported modules. Otherwise, you'll go an error like the following when trying to import the react-native-lawmaking-push module: error TS2307: Cannot discover module 'react-native-lawmaking-push'.
This projection has adopted the Microsoft Open Source Code of Conduct. For more data see the Lawmaking of Conduct FAQ or contact opencode@microsoft.com with any additional questions or comments.
Source: https://www.npmjs.com/package/react-native-code-push
0 Response to "Error When Trying to Upload File(S) to Hockeyapp: 404-"
Post a Comment