Facebook/react github

Facebook/react github DEFAULT

reactnative.dev · CC BY licenseCircle CI StatusPRs WelcomeFollow @reactnative

This repo contains the website configuration and documentation powering the React Native website.

If you are looking for the source code of the React Native Archive website select the branch.


Getting started


  1. Git.
  2. Node(version 12 or greater).
  3. Yarn(version or greater).
  4. A fork of the repo (for any contributions).
  5. A clone of the repo.


  1. to go into the project root.
  2. to install the website's workspace dependencies.

Running locally

  1. to go into the website portion of the project.
  2. to start the development server (powered by Docusaurus).
  3. to open the site in your favorite browser.


If you would like to contribute an edit or addition to the docs, read through our style guide before you write anything. All our content is generated from markdown files you can find in the directory.

To edit the internals of how the site is built, you may want to get familiarized with how the site is built. The React Native website is a static site generated using Docusaurus. The website configuration can be found in the directory. Visit the Docusaurus website to learn more about all the available configuration options.

Directory Structure

The following is a high-level overview of relevant files and folders.

Documentation sources

As mentioned above, the folder contains the source files for all of the docs in the React Native website. In most cases, you will want to edit the files within this directory. If you're adding a new doc or you need to alter the order the docs appear in the sidebar, take a look at the file in the directory. The sidebars file contains a list of document ids that should match those defined in the header metadata (aka frontmatter) of the docs markdown files.

Versioned docs

The React Native website is versioned to allow users to go back and see the API reference docs for any given release. A new version of the website is generally generated whenever there is a new React Native release. When this happens, any changes made to the and files will be copied over to the corresponding location within and .

Note: Do not edit the auto-generated files within or unless you are sure it is necessary. Edits made to older versions will not be propagated to newer versions of the docs.

Docusaurus keeps track of the list of versions for the site in the file. The ordering of the versions in this file should be in reverse chronological order.

Cutting a new version

  1. to go into the project root.
  2. to go into the website portion of the project.
  3. Run where is the new version being released.

Website configuration

The main config file for the website can be found at . This file tells Docusaurus how to build the website. Edits to this file are rarely necessary.

The subdirectory contains JavaScript and React components that are the core part of the website.

The subdirectory contains the React components that make up the non-documentation pages of the site, such as the homepage.

The subdirectory contains the swizzled React components from the Docusaurus theme.

The file contains the list of users that are highlighted in the React Native showcase.


Create a branch

  1. from any folder in your local repository.
  2. to ensure you have the latest main code.
  3. to create a branch.

    replace with a suitable name, such as

Make the change

  1. Follow the "Running locally" instructions.
  2. Save the files and check in the browser.
  3. Some changes may require a server restart to generate new files. (Pages in always do!)
  4. Edits to pages in will only be visible in the latest version of the documentation, called "Next", located under the path.

Visit http://localhost/docs/next/YOUR-DOCS-PAGE to see your work.

Visit http://localhost/versions to see the list of all versions of the docs.

Test the change

If possible, test any visual changes in all latest versions of the following browsers:

  • Chrome and Firefox on the desktop.
  • Chrome and Safari on mobile.

Push it

  1. Run and in directory to ensure your changes are consistent with other files in the repo.
  2. to stage and commit your changes.

    replace with a commit message, such as

  3. Go to the react-native-website repo and you should see recently pushed branches.
  4. Follow GitHub's instructions.
  5. Describe briefly your changes (in case of visual changes, please include screenshots).


React Native is MIT licensed.

React Native documentation is Creative Commons licensed.

Sours: https://github.com/facebook/react-native-website



React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes.

Declarative views make your code more predictable and easier to debug.


Build encapsulated components that manage their own state, then compose them to make complex UIs.

Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM.

Learn Once, Write Anywhere

We don’t make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code.

React can also render on the server using Node and power mobile apps using React Native.

A Simple Component

React components implement a method that takes input data and returns what to display. This example uses an XML-like syntax called JSX. Input data that is passed into the component can be accessed by via .

JSX is optional and not required to use React. Try the Babel REPL to see the raw JavaScript code produced by the JSX compilation step.

Loading code example

A Stateful Component

In addition to taking input data (accessed via ), a component can maintain internal state data (accessed via ). When a component’s state data changes, the rendered markup will be updated by re-invoking .

Loading code example

An Application

Using and , we can put together a small Todo application. This example uses to track the current list of items as well as the text that the user has entered. Although event handlers appear to be rendered inline, they will be collected and implemented using event delegation.

Loading code example

A Component Using External Plugins

React allows you to interface with other libraries and frameworks. This example uses remarkable, an external Markdown library, to convert the ’s value in real time.

Loading code example

Sours: https://reactjs.org/
  1. Lexus is comparison
  2. Poison recipe 5e
  3. Pre algebra tutorial videos
  4. 17 month planner 2015

React Authentication with Twitter, Google, Facebook and Github

Since the server is where we are going to store the API keys, we will need to get those keys from the providers that we are working with. Here are the instructions to get your keys for Twitter, Google, Facebook and Github.

Make sure that callback URL you provide when registering an app is in the form:


After signing up for each provider we need to plug those keys into a .env file on the server. If you need a little help with that, please read this.

We are now ready to move on to writing the server:

Server.js is pretty lightweight as a lot of the functionality for the application will be shelled off to other files.

The key bits to note are that the application is started in HTTPS mode on line 22 (more on that below) and that the sockets are set directly on the app on line 45. By attaching the socket to the app, the socket can be accessed in the routes at a future point in time when we need to communicate with the client.

On to the PassportJS setup:

We are pulling in the strategies for the different providers that we are working with and adding those to the Passport singleton so they can be used throughout the application. If you have worked with Passport before this will feel familiar.

If you haven’t worked with Passport before, this is a great tutorial.

What is a little unusual above is that the callback on line 21 is the same for all the OAuth providers. Normally that callback is where you would save the user to a database and would need to be configured for every provider individually.

Because saving user data is not a focus of this tutorial, the callback is intentionally generic in this example.

With Passport all set up and ready to go, lets take a look at the router:

We have some setup to incorporate the PassportJS middleware and then have written a small piece of middleware on line 17 to attach the socket id of the connected client that comes in on req.query to req.session.

addSocketIdToSession — Attaches the socket id to the session and allows the server to send back the correct user info to the correct socket when the authentication process is complete with an OAuth provider.

I like to break up routes and callbacks into different files on the server to keep code modularized. But the previous file and the next file could be combined.

Time to look at the next (and final!) file:

Because we used app.set(‘io’, io) in server.js we now have access to the sockets from anywhere in the application that has a request in scope. This is super handy as we can now accept a callback from an OAuth provider and then relay the user’s info to the client via sockets.

Although this code is quite repetitive, at some point we have to build a user Object to send to the client and every OAuth provider sends their data in a different shape. Given that, there does not appear to be a way to avoid what feels like unnecessary boilerplate.

<side note> I would normally move configuration functionality like this into the callbacks of the passportInit function as mentioned above and move the user into a database at that point in time. But this seemed more straightforward given we are not saving any user data in this tutorial. </side note>

And thats it!

The server is not as easily extensible as the client, but we have established a solid pattern where adding an additional OAuth provider requires installing/configuring the PassportJS package for that provider, setting up a couple routes and writing a controller method.

Not too bad.

Sours: https://codeburst.io/react-authentication-with-twitter-google-facebook-and-githubd

React · GitHub licensenpm versionCircleCI StatusPRs Welcome

React is a JavaScript library for building user interfaces.

  • Declarative: React makes it painless to create interactive UIs. Design simple views for each state in your application, and React will efficiently update and render just the right components when your data changes. Declarative views make your code more predictable, simpler to understand, and easier to debug.
  • Component-Based: Build encapsulated components that manage their own state, then compose them to make complex UIs. Since component logic is written in JavaScript instead of templates, you can easily pass rich data through your app and keep state out of the DOM.
  • Learn Once, Write Anywhere: We don't make assumptions about the rest of your technology stack, so you can develop new features in React without rewriting existing code. React can also render on the server using Node and power mobile apps using React Native.

Learn how to use React in your own project.


React has been designed for gradual adoption from the start, and you can use as little or as much React as you need:

You can use React as a tag from a CDN, or as a package on npm.


You can find the React documentation on the website.

Check out the Getting Started page for a quick overview.

The documentation is divided into several sections:

You can improve it by sending pull requests to this repository.


We have several examples on the website. Here is the first one to get you started:

functionHelloMessage({ name }){return<div>Hello {name}</div>;}ReactDOM.render(<HelloMessagename="Taylor"/>,document.getElementById('container'));

This example will render "Hello Taylor" into a container on the page.

You'll notice that we used an HTML-like syntax; we call it JSX. JSX is not required to use React, but it makes code more readable, and writing it feels like writing HTML. If you're using React as a tag, read this section on integrating JSX; otherwise, the recommended JavaScript toolchains handle it automatically.


The main purpose of this repository is to continue evolving React core, making it faster and easier to use. Development of React happens in the open on GitHub, and we are grateful to the community for contributing bugfixes and improvements. Read below to learn how you can take part in improving React.

Code of Conduct

Facebook has adopted a Code of Conduct that we expect project participants to adhere to. Please read the full text so that you can understand what actions will and will not be tolerated.

Contributing Guide

Read our contributing guide to learn about our development process, how to propose bugfixes and improvements, and how to build and test your changes to React.

Good First Issues

To help you get your feet wet and get you familiar with our contribution process, we have a list of good first issues that contain bugs which have a relatively limited scope. This is a great place to get started.


React is MIT licensed.

Sours: https://github.com/facebook/react

Github facebook/react

Getting Started with React Native

Try the Demo#

Check out our React Native Demo app. Check out our FBT Native Module on NPM.

Adding FBT and its dependencies#

  • Dependencies

    • Make sure your fbt has a version greater than

  • Create a or file to add the transformation plugins with the following content:


"plugins": ["babel-plugin-fbt", "babel-plugin-fbt-runtime"],

"presets": ["module:metro-react-native-babel-preset"]



  • Update your Android main activity so that the app reloads whenever the user changes the locale
  • Add in in the . This will restart the app whenever the language of the device changes and will load the correct translations.


  • Copy the files in the i18n folder of the demo app into your app. Find an explanation of each file below:



  • JavaScript wrapper around the native module
  • Implements a local cache for translations to avoid unnecessary trips to the native side
  • The Android Native Module in the package, is used to read translations from Android resources. This module reads translations from files where xx/XX are the languageCode-countryCode respectively (more on Android resources naming here) with the following structure:

The hash values are the jenkins' hashes generated by the collectFbt script. Notice the escaped quotes in the translated string since this file will be converted into JSON by your app.


  • React Native specific hook to tell the FBT package how to load strings in your application


  • Injects the getTranslatedInput hook into FBT
  • This file must be imported in your app's entry file, before any other imports, to make FBT available for any static strings you may need to translate in your app. See an example in our index.js


  • After adding the native module, run to add the new module to your app
  • Add the languages you want your app to support
    • Name the files as this is what the native module will look for when looking for translations

Note: Please, remember you need to escape your quotes when writing your translation strings on iOS. See an example in our test app.

Add the FBT scripts in your package.json file#

  • Add the manifest script call in package.json. This script looks for all the files that import fbt and creates the input for the collectFbt script below:

"manifest": "fbt-manifest --src src/ --enum-manifest i18n/fbt/.enum_manifest.json --src-manifest i18n/fbt/.src_manifest.json"

  • Add the collectFbt script call in package.json. This script collects all fbt-wrapped strings into a file for you to translate.

"collect-fbts": "fbt-collect --hash-module fb-tiger-hash --react-native-mode --manifest < i18n/fbt/.src_manifest.json > i18n/fbt/.source_strings.json"

  • Add the translate script call in package.json. This script should be used after all strings are translated. It'll generate a single file with all translations that we then need to translate into Android specific localizable.json files. See the input format here.

"translate-fbts": "fbt-translate --jenkins --source-strings i18n/fbt/.source_strings.json --translations i18n/fbt/translationScriptInput/*.json > i18n/fbt/translatedFbts.json"

  • Generate localizable.json files for each language and add them to the corresponding folder (xx is the ISO 2 Letter Language Codes and XX is the ISO 2 Letter Country Code). You can find a helper script in our test app: generate-android-localizables.js. This script takes in the translation script output and generates localizable.json files in the folder:


├── raw

│ └── localizable.json

├── raw-es-rES

│ └── localizable.json

└── values

├── strings.xml

└── styles.xml


Sours: https://facebook.github.io/fbt/docs/getting_started_react_native
React App on Github - Using Git to set up our React App on Github

"Well, I can provide for a fee. " Yeah. She would have known that I was a professional in these games. So so. You are in trouble.

You will also be interested:

I kiss you in the chest. When will you be free. It means the end.

4097 4098 4099 4100 4101