Github Repos

  • Build an API for your next web application, using Node, Express and MongoDB
    0 🍴1 ⭐Updated 2 days agoJavaScript

    Node workshop

    to follow workshop:

    $ git checkout dev
    $ node server.js

    to dev latest

    $ git checkout master
    $ npm start

    Create a .env file on root

    # API keys go here
  • Build blazing fast, modern apps and websites with React
    0 🍴1 ⭐Updated 2 days agoJavaScript


    Gatsby v2

    βš›οΈ πŸ“„ πŸš€

    Fast in every way that matters

    Gatsby is a free and open source framework based on React that helps developers build blazing fast websites and apps

    Gatsby is released under the MIT license. Current CircleCI build status. Current npm package version. Downloads per month on npm. Total downloads on npm. PRs welcome! Follow @gatsbyjs

    Quickstart Β· Tutorial Β· Plugins Β· Starters Β· Showcase Β· Contribute Β· Support: Spectrum & Discord

    Gatsby is a modern web framework for blazing fast websites.

    • Go Beyond Static Websites. Get all the benefits of static websites with none of the limitations. Gatsby sites are fully functional React apps so you can create high-quality, dynamic web apps, from blogs to e-commerce sites to user dashboards.

    • Use a Modern Stack for Every Site. No matter where the data comes from, Gatsby sites are built using React and GraphQL. Build a uniform workflow for you and your team, regardless of whether the data is coming from the same backend.

    • Load Data From Anywhere. Gatsby pulls in data from any data source, whether it’s Markdown files, a headless CMS like Contentful or WordPress, or a REST or GraphQL API. Use source plugins to load your data, then develop using Gatsby’s uniform GraphQL interface.

    • Performance Is Baked In. Ace your performance audits by default. Gatsby automates code splitting, image optimization, inlining critical styles, lazy-loading, prefetching resources, and more to ensure your site is fast β€” no manual tuning required.

    • Host at Scale for Pennies. Gatsby sites don’t require servers so you can host your entire site on a CDN for a fraction of the cost of a server-rendered site. Many Gatsby sites can be hosted entirely free on services like GitHub Pages and Netlify.

    Learn how to use Gatsby for your next project.

    What’s In This Document

    πŸš€ Get Up and Running in 5 Minutes

    You can get a new Gatsby site up and running on your local dev environment in 5 minutes with these four steps:

    1. Install the Gatsby CLI.

      npm install -g gatsby-cli
    2. Create a Gatsby site from a Gatsby starter.

      Get your Gatsby blog set up in a single command:

      # create a new Gatsby site using the default starter
      gatsby new my-blazing-fast-site
    3. Start the site in develop mode.

      Next, move into your new site’s directory and start it up:

      cd my-blazing-fast-site/
      gatsby develop
    4. Open the source code and start editing!

      Your site is now running at http://localhost:8000. Open the my-blazing-fast-site directory in your code editor of choice and edit src/pages/index.js. Save your changes, and the browser will update in real time!

    At this point, you’ve got a fully functional Gatsby website. For additional information on how you can customize your Gatsby site, see our plugins and the official tutorial.

    πŸŽ“ Learning Gatsby

    Full documentation for Gatsby lives on the website.

    • For most developers, we recommend starting with our in-depth tutorial for creating a site with Gatsby. It starts with zero assumptions about your level of ability and walks through every step of the process.

    • To dive straight into code samples head to our documentation. In particular, check out the β€œGuides”, β€œAPI Reference”, and β€œAdvanced Tutorials” sections in the sidebar.

    We welcome suggestions for improving our docs. See the β€œhow to contribute” documentation for more details.

    Start Learning Gatsby: Follow the Tutorial Β· Read the Docs

    πŸ’Ό Migration Guides

    Already have a Gatsby site? These handy guides will help you add the improvements of Gatsby v2 to your site without starting from scratch!

    ❗ Code of Conduct

    Gatsby is dedicated to building a welcoming, diverse, safe community. We expect everyone participating in the Gatsby community to abide by our Code of Conduct. Please read it. Please follow it. In the Gatsby community, we work hard to build each other up and create amazing things together. πŸ’ͺπŸ’œ

    🀝 How to Contribute

    Whether you're helping us fix bugs, improve the docs, or spread the word, we'd love to have you as part of the Gatsby community! :muscle::purple_heart:

    Check out our Contributing Guide for ideas on contributing and setup steps for getting our repositories up and running on your local machine.

    A note on how this repository is organized

    This repository is a monorepo managed using Lerna. This means there are multiple packages managed in this codebase, even though we publish them to NPM as separate packages.

    Contributing to Gatsby v1

    We are currently only accepting bug fixes for Gatsby v1. No new features will be accepted.

    :memo: License

    Licensed under the MIT License.

    πŸ’œ Thanks

    Thanks to our many contributors and to Netlify for hosting and our example sites.

  • Promise based HTTP client for the browser and node.js
    0 🍴1 ⭐Updated 2 days agoJavaScript


    npm version CDNJS build status code coverage install size npm downloads gitter chat code helpers

    Promise based HTTP client for the browser and node.js

    Table of Contents


    • Make XMLHttpRequests from the browser
    • Make http requests from node.js
    • Supports the Promise API
    • Intercept request and response
    • Transform request and response data
    • Cancel requests
    • Automatic transforms for JSON data
    • Client side support for protecting against XSRF

    Browser Support

    Latest βœ”Latest βœ”Latest βœ”Latest βœ”Latest βœ”11 βœ”

    Browser Matrix


    Using npm:

    $ npm install axios

    Using bower:

    $ bower install axios

    Using yarn:

    $ yarn add axios

    Using jsDelivr CDN:

    <script src=""></script>

    Using unpkg CDN:

    <script src=""></script>


    note: CommonJS usage

    In order to gain the TypeScript typings (for intellisense / autocomplete) while using CommonJS imports with require() use the following approach:

    const axios = require('axios').default;
    // axios.<method> will now provide autocomplete and parameter typings

    Performing a GET request

    const axios = require('axios');
    // Make a request for a user with a given ID
      .then(function (response) {
        // handle success
      .catch(function (error) {
        // handle error
      .then(function () {
        // always executed
    // Optionally the request above could also be done as
    axios.get('/user', {
        params: {
          ID: 12345
      .then(function (response) {
      .catch(function (error) {
      .then(function () {
        // always executed
    // Want to use async/await? Add the `async` keyword to your outer function/method.
    async function getUser() {
      try {
        const response = await axios.get('/user?ID=12345');
      } catch (error) {

    NOTE: async/await is part of ECMAScript 2017 and is not supported in Internet Explorer and older browsers, so use with caution.

    Performing a POST request'/user', {
        firstName: 'Fred',
        lastName: 'Flintstone'
      .then(function (response) {
      .catch(function (error) {

    Performing multiple concurrent requests

    function getUserAccount() {
      return axios.get('/user/12345');
    function getUserPermissions() {
      return axios.get('/user/12345/permissions');
    Promise.all([getUserAccount(), getUserPermissions()])
      .then(function (results) {
        const acct = results[0];
        const perm = results[1];

    axios API

    Requests can be made by passing the relevant config to axios.

    // Send a POST request
      method: 'post',
      url: '/user/12345',
      data: {
        firstName: 'Fred',
        lastName: 'Flintstone'
    // GET request for remote image in node.js
      method: 'get',
      url: '',
      responseType: 'stream'
      .then(function (response) {'ada_lovelace.jpg'))
    axios(url, config)
    // Send a GET request (default method)

    Request method aliases

    For convenience aliases have been provided for all supported request methods.

    axios.get(url, config)
    axios.delete(url, config)
    axios.head(url, config)
    axios.options(url, config)[, data, config])
    axios.put(url[, data, config])
    axios.patch(url[, data, config])

    When using the alias methods url, method, and data properties don't need to be specified in config.

    Concurrency (Deprecated)

    Please use Promise.all to replace the below functions.

    Helper functions for dealing with concurrent requests.

    axios.all(iterable) axios.spread(callback)

    Creating an instance

    You can create a new instance of axios with a custom config.

    const instance = axios.create({
      baseURL: '',
      timeout: 1000,
      headers: {'X-Custom-Header': 'foobar'}

    Instance methods

    The available instance methods are listed below. The specified config will be merged with the instance config.

    axios#get(url, config)
    axios#delete(url, config)
    axios#head(url, config)
    axios#options(url, config)
    axios#post(url[, data, config])
    axios#put(url[, data, config])
    axios#patch(url[, data, config])

    Request Config

    These are the available config options for making requests. Only the url is required. Requests will default to GET if method is not specified.

      // `url` is the server URL that will be used for the request
      url: '/user',
      // `method` is the request method to be used when making the request
      method: 'get', // default
      // `baseURL` will be prepended to `url` unless `url` is absolute.
      // It can be convenient to set `baseURL` for an instance of axios to pass relative URLs
      // to methods of that instance.
      baseURL: '',
      // `transformRequest` allows changes to the request data before it is sent to the server
      // This is only applicable for request methods 'PUT', 'POST', 'PATCH' and 'DELETE'
      // The last function in the array must return a string or an instance of Buffer, ArrayBuffer,
      // FormData or Stream
      // You may modify the headers object.
      transformRequest: [function (data, headers) {
        // Do whatever you want to transform the data
        return data;
      // `transformResponse` allows changes to the response data to be made before
      // it is passed to then/catch
      transformResponse: [function (data) {
        // Do whatever you want to transform the data
        return data;
      // `headers` are custom headers to be sent
      headers: {'X-Requested-With': 'XMLHttpRequest'},
      // `params` are the URL parameters to be sent with the request
      // Must be a plain object or a URLSearchParams object
      params: {
        ID: 12345
      // `paramsSerializer` is an optional function in charge of serializing `params`
      // (e.g.,
      paramsSerializer: function (params) {
        return Qs.stringify(params, {arrayFormat: 'brackets'})
      // `data` is the data to be sent as the request body
      // Only applicable for request methods 'PUT', 'POST', 'DELETE , and 'PATCH'
      // When no `transformRequest` is set, must be of one of the following types:
      // - string, plain object, ArrayBuffer, ArrayBufferView, URLSearchParams
      // - Browser only: FormData, File, Blob
      // - Node only: Stream, Buffer
      data: {
        firstName: 'Fred'
      // syntax alternative to send data into the body
      // method post
      // only the value is sent, not the key
      data: 'Country=Brasil&City=Belo Horizonte',
      // `timeout` specifies the number of milliseconds before the request times out.
      // If the request takes longer than `timeout`, the request will be aborted.
      timeout: 1000, // default is `0` (no timeout)
      // `withCredentials` indicates whether or not cross-site Access-Control requests
      // should be made using credentials
      withCredentials: false, // default
      // `adapter` allows custom handling of requests which makes testing easier.
      // Return a promise and supply a valid response (see lib/adapters/
      adapter: function (config) {
        /* ... */
      // `auth` indicates that HTTP Basic auth should be used, and supplies credentials.
      // This will set an `Authorization` header, overwriting any existing
      // `Authorization` custom headers you have set using `headers`.
      // Please note that only HTTP Basic auth is configurable through this parameter.
      // For Bearer tokens and such, use `Authorization` custom headers instead.
      auth: {
        username: 'janedoe',
        password: 's00pers3cret'
      // `responseType` indicates the type of data that the server will respond with
      // options are: 'arraybuffer', 'document', 'json', 'text', 'stream'
      //   browser only: 'blob'
      responseType: 'json', // default
      // `responseEncoding` indicates encoding to use for decoding responses (Node.js only)
      // Note: Ignored for `responseType` of 'stream' or client-side requests
      responseEncoding: 'utf8', // default
      // `xsrfCookieName` is the name of the cookie to use as a value for xsrf token
      xsrfCookieName: 'XSRF-TOKEN', // default
      // `xsrfHeaderName` is the name of the http header that carries the xsrf token value
      xsrfHeaderName: 'X-XSRF-TOKEN', // default
      // `onUploadProgress` allows handling of progress events for uploads
      // browser only
      onUploadProgress: function (progressEvent) {
        // Do whatever you want with the native progress event
      // `onDownloadProgress` allows handling of progress events for downloads
      // browser only
      onDownloadProgress: function (progressEvent) {
        // Do whatever you want with the native progress event
      // `maxContentLength` defines the max size of the http response content in bytes allowed in node.js
      maxContentLength: 2000,
      // `maxBodyLength` (Node only option) defines the max size of the http request content in bytes allowed
      maxBodyLength: 2000,
      // `validateStatus` defines whether to resolve or reject the promise for a given
      // HTTP response status code. If `validateStatus` returns `true` (or is set to `null`
      // or `undefined`), the promise will be resolved; otherwise, the promise will be
      // rejected.
      validateStatus: function (status) {
        return status >= 200 && status < 300; // default
      // `maxRedirects` defines the maximum number of redirects to follow in node.js.
      // If set to 0, no redirects will be followed.
      maxRedirects: 5, // default
      // `socketPath` defines a UNIX Socket to be used in node.js.
      // e.g. '/var/run/docker.sock' to send requests to the docker daemon.
      // Only either `socketPath` or `proxy` can be specified.
      // If both are specified, `socketPath` is used.
      socketPath: null, // default
      // `httpAgent` and `httpsAgent` define a custom agent to be used when performing http
      // and https requests, respectively, in node.js. This allows options to be added like
      // `keepAlive` that are not enabled by default.
      httpAgent: new http.Agent({ keepAlive: true }),
      httpsAgent: new https.Agent({ keepAlive: true }),
      // `proxy` defines the hostname and port of the proxy server.
      // You can also define your proxy using the conventional `http_proxy` and
      // `https_proxy` environment variables. If you are using environment variables
      // for your proxy configuration, you can also define a `no_proxy` environment
      // variable as a comma-separated list of domains that should not be proxied.
      // Use `false` to disable proxies, ignoring environment variables.
      // `auth` indicates that HTTP Basic auth should be used to connect to the proxy, and
      // supplies credentials.
      // This will set an `Proxy-Authorization` header, overwriting any existing
      // `Proxy-Authorization` custom headers you have set using `headers`.
      proxy: {
        host: '',
        port: 9000,
        auth: {
          username: 'mikeymike',
          password: 'rapunz3l'
      // `cancelToken` specifies a cancel token that can be used to cancel the request
      // (see Cancellation section below for details)
      cancelToken: new CancelToken(function (cancel) {
      // `decompress` indicates whether or not the response body should be decompressed 
      // automatically. If set to `true` will also remove the 'content-encoding' header 
      // from the responses objects of all decompressed responses
      // - Node only (XHR cannot turn off decompression)
      decompress: true // default

    Response Schema

    The response for a request contains the following information.

      // `data` is the response that was provided by the server
      data: {},
      // `status` is the HTTP status code from the server response
      status: 200,
      // `statusText` is the HTTP status message from the server response
      statusText: 'OK',
      // `headers` the HTTP headers that the server responded with
      // All header names are lower cased and can be accessed using the bracket notation.
      // Example: `response.headers['content-type']`
      headers: {},
      // `config` is the config that was provided to `axios` for the request
      config: {},
      // `request` is the request that generated this response
      // It is the last ClientRequest instance in node.js (in redirects)
      // and an XMLHttpRequest instance in the browser
      request: {}

    When using then, you will receive the response as follows:

      .then(function (response) {

    When using catch, or passing a rejection callback as second parameter of then, the response will be available through the error object as explained in the Handling Errors section.

    Config Defaults

    You can specify config defaults that will be applied to every request.

    Global axios defaults

    axios.defaults.baseURL = '';
    axios.defaults.headers.common['Authorization'] = AUTH_TOKEN;['Content-Type'] = 'application/x-www-form-urlencoded';

    Custom instance defaults

    // Set config defaults when creating the instance
    const instance = axios.create({
      baseURL: ''
    // Alter defaults after instance has been created
    instance.defaults.headers.common['Authorization'] = AUTH_TOKEN;

    Config order of precedence

    Config will be merged with an order of precedence. The order is library defaults found in lib/defaults.js, then defaults property of the instance, and finally config argument for the request. The latter will take precedence over the former. Here's an example.

    // Create an instance using the config defaults provided by the library
    // At this point the timeout config value is `0` as is the default for the library
    const instance = axios.create();
    // Override timeout default for the library
    // Now all requests using this instance will wait 2.5 seconds before timing out
    instance.defaults.timeout = 2500;
    // Override timeout for this request as it's known to take a long time
    instance.get('/longRequest', {
      timeout: 5000


    You can intercept requests or responses before they are handled by then or catch.

    // Add a request interceptor
    axios.interceptors.request.use(function (config) {
        // Do something before request is sent
        return config;
      }, function (error) {
        // Do something with request error
        return Promise.reject(error);
    // Add a response interceptor
    axios.interceptors.response.use(function (response) {
        // Any status code that lie within the range of 2xx cause this function to trigger
        // Do something with response data
        return response;
      }, function (error) {
        // Any status codes that falls outside the range of 2xx cause this function to trigger
        // Do something with response error
        return Promise.reject(error);

    If you need to remove an interceptor later you can.

    const myInterceptor = axios.interceptors.request.use(function () {/*...*/});

    You can add interceptors to a custom instance of axios.

    const instance = axios.create();
    instance.interceptors.request.use(function () {/*...*/});

    Handling Errors

      .catch(function (error) {
        if (error.response) {
          // The request was made and the server responded with a status code
          // that falls out of the range of 2xx
        } else if (error.request) {
          // The request was made but no response was received
          // `error.request` is an instance of XMLHttpRequest in the browser and an instance of
          // http.ClientRequest in node.js
        } else {
          // Something happened in setting up the request that triggered an Error
          console.log('Error', error.message);

    Using the validateStatus config option, you can define HTTP code(s) that should throw an error.

    axios.get('/user/12345', {
      validateStatus: function (status) {
        return status < 500; // Resolve only if the status code is less than 500

    Using toJSON you get an object with more information about the HTTP error.

      .catch(function (error) {


    You can cancel a request using a cancel token.

    The axios cancel token API is based on the withdrawn cancelable promises proposal.

    You can create a cancel token using the CancelToken.source factory as shown below:

    const CancelToken = axios.CancelToken;
    const source = CancelToken.source();
    axios.get('/user/12345', {
      cancelToken: source.token
    }).catch(function (thrown) {
      if (axios.isCancel(thrown)) {
        console.log('Request canceled', thrown.message);
      } else {
        // handle error
    });'/user/12345', {
      name: 'new name'
    }, {
      cancelToken: source.token
    // cancel the request (the message parameter is optional)
    source.cancel('Operation canceled by the user.');

    You can also create a cancel token by passing an executor function to the CancelToken constructor:

    const CancelToken = axios.CancelToken;
    let cancel;
    axios.get('/user/12345', {
      cancelToken: new CancelToken(function executor(c) {
        // An executor function receives a cancel function as a parameter
        cancel = c;
    // cancel the request

    Note: you can cancel several requests with the same cancel token.

    Using application/x-www-form-urlencoded format

    By default, axios serializes JavaScript objects to JSON. To send data in the application/x-www-form-urlencoded format instead, you can use one of the following options.


    In a browser, you can use the URLSearchParams API as follows:

    const params = new URLSearchParams();
    params.append('param1', 'value1');
    params.append('param2', 'value2');'/foo', params);

    Note that URLSearchParams is not supported by all browsers (see, but there is a polyfill available (make sure to polyfill the global environment).

    Alternatively, you can encode data using the qs library:

    const qs = require('qs');'/foo', qs.stringify({ 'bar': 123 }));

    Or in another way (ES6),

    import qs from 'qs';
    const data = { 'bar': 123 };
    const options = {
      method: 'POST',
      headers: { 'content-type': 'application/x-www-form-urlencoded' },
      data: qs.stringify(data),


    Query string

    In node.js, you can use the querystring module as follows:

    const querystring = require('querystring');'', querystring.stringify({ foo: 'bar' }));

    or 'URLSearchParams' from 'url module' as follows:

    const url = require('url');
    const params = new url.URLSearchParams({ foo: 'bar' });'', params.toString());

    You can also use the qs library.


    The qs library is preferable if you need to stringify nested objects, as the querystring method has known issues with that use case (

    Form data

    In node.js, you can use the form-data library as follows:

    const FormData = require('form-data');
    const form = new FormData();
    form.append('my_field', 'my value');
    form.append('my_buffer', new Buffer(10));
    form.append('my_file', fs.createReadStream('/foo/bar.jpg'));'', form, { headers: form.getHeaders() })

    Alternatively, use an interceptor:

    axios.interceptors.request.use(config => {
      if ( instanceof FormData) {
      return config;


    Until axios reaches a 1.0 release, breaking changes will be released with a new minor version. For example 0.5.1, and 0.5.4 will have the same API, but 0.6.0 will have breaking changes.


    axios depends on a native ES6 Promise implementation to be supported. If your environment doesn't support ES6 Promises, you can polyfill.


    axios includes TypeScript definitions.

    import axios from 'axios';



    axios is heavily inspired by the $http service provided in Angular. Ultimately axios is an effort to provide a standalone $http-like service for use outside of Angular.



  • A declarative, efficient, and flexible JavaScript library for building user interfaces.
    0 🍴1 ⭐Updated 2 days agoJavaScript

    React Β· GitHub license npm version CircleCI Status PRs 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 <script> tag from a CDN, or as a react 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:

    function HelloMessage({ name }) {
      return <div>Hello {name}</div>;
      <HelloMessage name="Taylor" />,

    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 <script> 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.

  • Fast, unopinionated, minimalist web framework for node.
    0 🍴1 ⭐Updated 2 days agoJavaScript
  • πŸ““ The UI component workshop. Develop, document, & test for React, Vue, Angular, Ember, Web Components, & more!
    0 🍴1 ⭐Updated 2 days agoTypeScript


    Build bulletproof UI components faster

    Build Status on CircleCI CodeFactor Known Vulnerabilities codecov License
    Storybook Slack Backers on Open Collective Sponsors on Open Collective Official Twitter Handle

    Storybook is a development environment for UI components. It allows you to browse a component library, view the different states of each component, and interactively develop and test components.

    View README for:
    latest next


    Storybook runs outside of your app. This allows you to develop UI components in isolation, which can improve component reuse, testability, and development speed. You can build quickly without having to worry about application-specific dependencies.

    Here are some featured examples that you can reference to see how Storybook works:

    Storybook comes with a lot of addons for component design, documentation, testing, interactivity, and so on. Storybook's API makes it possible to configure and extend in various ways. It has even been extended to support React Native development for mobile.

    Table of contents

    Getting Started

    First install storybook:

    cd my-react-app
    npx -p @storybook/cli sb init

    If you'd rather set up your project manually, take a look at our Slow Start Guide.

    Once it's installed, you can npm run storybook and it will run the development server on your local machine, and give you a URL to browse some sample stories.

    Storybook v2.x migration note: If you're using Storybook v2.x and want to shift to 4.x version the easiest way is:

    cd my-storybook-v2-app
    npx -p @storybook/cli sb init

    It runs a codemod to update all package names. Read all migration details in our Migration Guide

    For full documentation on using Storybook visit:

    For additional help, join us in our Discord or Slack


    Supported Frameworks

    React Native-React Native

    Sub Projects

    • CLI - Streamlined installation for a variety of app types
    • examples - Code examples to illustrate different Storybook use cases


    a11yTest components for user accessibility in Storybook
    actionsLog actions as users interact with components in the Storybook UI
    backgroundsLet users choose backgrounds in the Storybook UI
    centeredCenter the alignment of your components within the Storybook UI
    contextsInteractively inject component contexts for stories in the Storybook UI
    cssresourcesDynamically add/remove css resources to the component iframe
    design assetsView images, videos, weblinks alongside your story
    eventsInteractively fire events to components that respond to EventEmitter
    graphqlQuery a GraphQL server within Storybook stories
    google-analyticsReports google analytics on stories
    infoAnnotate stories with extra component usage information
    jestView the results of components' unit tests in Storybook
    knobsInteractively edit component prop data in the Storybook UI
    linksCreate links between stories
    notesAnnotate Storybook stories with notes
    optionsCustomize the Storybook UI in code
    storyshotsSnapshot testing for components in Storybook
    storysourceView the code of your stories within the Storybook UI
    viewportChange display sizes and layouts for responsive components using Storybook

    See Addon / Framework Support Table

    Badges & Presentation materials

    We have a badge! Link it to your live Storybook example.


    [![Storybook](](link to site)

    If you're looking for material to use in your presentation about storybook, like logo's video material and the colors we use etc, you can find all of that at our brand repo.



    We welcome contributions to Storybook!

    • πŸ“₯ Pull requests and 🌟 Stars are always welcome.
    • Read our contributing guide to get started, or find us on Discord, we will take the time to guide you

    Looking for a first issue to tackle?

    • We tag issues with Good First Issue when we think they are well suited for people who are new to the codebase or OSS in general.
    • Talk to us, we'll find something to suits your skills and learning interest.

    Development scripts

    Storybook is organized as a monorepo using Lerna. Useful scripts include:

    yarn bootstrap

    Installs package dependencies and links packages together - using lerna

    yarn run publish

    Push a release to git and npm will ask for version in interactive mode - using lerna.

    yarn lint

    boolean check if code conforms to linting rules - uses remark & eslint

    • yarn lint:js - will check js
    • yarn lint:md - will check markdown + code samples

    • yarn lint:js --fix - will automatically fix js

    yarn test

    boolean check if unit tests all pass - uses jest

    • yarn run test --core --watch - will run core tests in watch-mode


    Become a sponsor and get your logo on our README on Github with a link to your site. [Become a sponsor]


    Support us with a monthly donation and help us continue our activities. [Become a backer]



    -the end-

  • Sample repo to explore Github API
    0 🍴1 ⭐Updated a day agoJavaScript


    Sample repo to explore Github API