Learn Nwjs, Ramda and React-storybook

Learn how you can use ramda.js to bring functional programming concepts into your JavaScript code. Ramda offers composability and immutability right out of the box, so you can leave your imperative code behind and build cleaner, more maintainable code.

A library designed specifically for a functional programming style, one that makes it easy to create functional pipelines, one that never mutates user data.

ramda

Functional Programming in JavaScript with Ramda.js

React is one of the web’s most popular frameworks for building JavaScript applications. 

If you know what you’re doing, React can drastically simplify how you build, use, and maintain code.

Whether you’re a React newbie or you’re ready for advanced techniques, you can level-up with egghead. Explore our in-depth courses, lessons, and community resources to build more powerful applications and crack open your career.

react

Storybook is a UI component development environment for React, Vue, and Angular. With that, you can develop UI components without running your app.

Here I show how best to configure a React Storybook to use [Typescript](/q/typescript) (with TSX). This lets you write your reusable components with maximal type safety. Please see the provided code for the full source.

Configure React Storybook for use with Typescript

In this lesson we'll see how to use the `without` function to remove items in a known list from an array. Then we'll generate our exclusion list and apply it to `without` using `reduce`, `min`, `max` and `converge` to detect the highest and lowest values in an array and creating a new array that excludes those values.

Discard the High and Low Values From an Array of Numbers with Ramda

[Storybook](https://storybook.js.org/) is a framework that allows you to develop components in isolation. It is ideal for a variety of use cases, most commonly when you're building some shared component toolkit. As such, Nx comes with a dedicated package `@nrwl/storybook` that adds a series of useful code generators to add storybook to an existing React library, but also to automatically generate stories and more.

Use Storybook to Develop React Components in Nx

JavaScript® (often shortened to JS) is a lightweight, interpreted, object-oriented language with first-class functions, most known as the scripting language for Web pages, but used in many non-browser environments as well such as node.js or Apache CouchDB. It is a prototype-based, multi-paradigm scripting language that is dynamic, and supports object-oriented, imperative, and functional programming styles.

javascript

[Nx](https://nx.dev) combines a lot of the best tools on the market, integrates them, and provides tooling to provide the best possible developer experience. One such pair is [Cypress](https://www.cypress.io/) and [Storybook](https://storybook.js.org/). Storybook allows developing components in isolation, which is also a great basis for testing components, which is where Cypress shines.
In this lesson, we're exploring some of the `@nrwl/storybook` code generation utilities that allow you to not only configure Storybook for a React application but automatically also set up a Cypress test configuration for it along with some spec files generated from the Storybook stories.

Use Cypress and Storybook to test your React Components in Isolation

In this lesson we'll look at how you can use Ramda's `unfold` function to generate a list of values based on an initial seed.

Create an Array From a Seed Value with Ramda's unfold

NW.js is an app runtime based on `Chromium` and `node.js`. You can write native apps in HTML and JavaScript with NW.js. It also lets you call Node.js modules directly from the DOM and enables a new way of writing native applications with all Web technologies.

nwjs

Let's add some module loading to our NW.js. Webpack and dependency management FTW!

NW.js and Webpack: A match made in heaven

Functional composition is a great way to write declarative code that reads well. But sometimes, you need to get insight into what's happening at different steps in your composition. This is where `tap` comes in. With tap, we can run code that generates side-effects, like logging to the console, and our data will continue to be passed along, untouched.

Debug Function Compositions with Ramda's Tap Function

Most of the functions offered by the ramda library are curried by default. Functions you've created or that you've pulled in from another library may not be curried. Ramda's `curry` and `curryN` functions allow you to take a non-curried function and use it as a curried functions. In the case where you have a manually curried function and you want to just call it like a normal function, you can use `uncurryN` to get back a function that accepts all of the arguments at once.

Curry and Uncurry Functions with Ramda

In this lesson, we show how to setup React Storybook into an existing React project. We’ll go through common configuration files and how to adjust them.

Add React Storybook to a Project 

You can really unlock the power of ramda (and functional programming in general) when you combine functions. Counting words in a string may seem like a relatively difficult task, but ramda makes it easy by providing a `countBy` function.  This lesson walks through using the `countBy` to count words in a string.

Count Words in a String with Ramda's countBy and invert

Components trigger actions via function props to notify of events that occur within the Component. We can inspect those events using React Storybook.

Inspect Component Events with React Storybook

In this lesson, we'll refactor a React component to use Ramda lenses to update our component state. We'll create a lens to focus on the property we want to target and use `over` to apply the existing state value to a utility function and we'll get back a new state that will be reflected in our rendered UI.

Update Component State in React With Ramda Lenses

Using the map method of an array is a great way to create new data from an existing array in an immutable way and without writing any loops. The problem is that you need to call it on an existing array instance. In the lesson we'll see how to build our own reusable `map` utility function using manual currying and then we'll replace it with Ramda's `map`.

Create a Reusable Mapping Function with Ramda's Map

In this lesson, we'll use `Promise.all` to get an array that contains the resolved values from multiple promises. Then we'll see how we can use Ramda to convert that array of values into a single object using `zip` with `fromPairs`. Then we'll refactor to use `zipObj`.

Convert a Promise.all Result to an Object with Ramda's zip and zipObj

We don't always control the data we need in our applications, and that means we often find ourselves massaging and transforming our data. In this lesson, we'll learn how to transform objects in a declarative way using ramda's evolve function.

Declaratively Map Data Transformations to Object Properties Using Ramda evolve

In this lesson we'll see how Ramda's `path` and `pathOr` functions can be used to safely access a deeply nested property from an object while avoiding the dreaded checks for `undefined` at each new property in the desired path. 

Get Deeply Nested Properties Safely with Ramda's path and pathOr Functions

Sometimes you need to filter an array of objects or perform other conditional logic based on a combination of factors. Ramda's `where` function gives you a concise way to declaratively map individual predicates to object properties, that when combined, cover the various facets of your conditions. In this lesson, we'll look at how this powerful function can be used for scenarios requiring a complex predicate function.

Declaratively Map Predicates to Object Properties Using Ramda where

In this lesson we'll take an array of objects and map it to a new array where each object is a subset of the original. We'll look at multiple ways to accomplish this, refactoring our code into a simple and easy to read function using Ramda's `map`, `pick` and `project` functions.

Select a Subset of Properties from a Collection of Objects in Ramda



[React Storybook](https://github.com/kadirahq/react-storybook) is a UI component development environment for React.
With that, you can develop UI components without running your app.

Here I show how to get started with React Storybook.
For more information, have a look at our [documentation](https://getstorybook.io/docs).

Getting Started with React Storybook

React Component stories can be dynamically loaded into React Storybook instead of doing it manually every time.

Topics

Instructors

Content Type