Learn Angular-cli, Babel and Jekyll

Jekyll is a blog-aware static site generator. You can write text in markdown or HTML and Jekyll uses layouts to create a static website. You can tweak how you want the site URLs to look, what data gets displayed on the site, and more.

After watching the collection you'll be able to:

* Install Jeykll and run it locally
* Create a new blog post
* Install plugins to add new features to your blog

Jekyll is a parsing engine bundled as a ruby gem used to build static websites from dynamic components such as templates, partials, liquid code, markdown, etc. Jekyll is known as "a simple, blog aware, static site generator".

jekyll

Create A Blog With Jekyll

Babel has support for the latest version of JavaScript through syntax transformers. These plugins allow you to use new syntax, right now without waiting for browser support.

babel

Converting all of our modern JavaScript into ES5 compatible syntax is a great way to use modern features while targeting older browsers. What happens when the browsers natively support these language features? Then it no longer makes sense to transform that code or to include polyfills that will go unused. In this lesson, we’ll add the `@babel/polyfill` package and configure `babel-preset-env`

Target specific browsers with babel-preset-env and the babel pollyfill

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

We take the opengraph image we wrote in codesandbox and copy it into our serverless function. We use Rollup to compile the component into an IIFE (immediately invoked function expression) that can run in our headless browser environment and cover a wide set of rollup plugins that we need for compatibility. We end the lesson having successfully screenshot our opengraph react component from our Netlify Function

Compiling a React to an IIFE with Rollup to execute and render in a headless browser

Jekyll is a blog-aware, static site generator written in Ruby. 

Requirements:
* Ruby version 2.5.0 or above
* RubyGems

Install the Jekyll Ruby gem on macOS quickly with just a few terminal commands and have a blog-aware site running locally.

Install Jekyll and Create a New Project

Blogging is built into Jekyll. You write blog posts as markdown or HTML files and Jekyll turns them blog posts. They follow a specific naming convention to be picked up and used by Jekyll

All blog post files require front matter. Front matter is a snippet of YAML at the top of a file. Front matter is used to set your layouts and meta data.

Create New Blog Post with Jekyll

Jekyll has a plugin system that allows you to add custom features to your site. There are many plugins available or you can even write your own. You can view a list of plugins at [Planet Jekyll](https://github.com/planetjekyll/awesome-jekyll-plugins)

Liquid is a templating language written in Ruby to output to the browser 

[Liquid Documentation](https://shopify.github.io/liquid/)

Install a Jekyll Plugin

We can write our package using the latest JavaScript syntax with a compilation step. In this lesson we will install `babel-cli` and `babel-preset-latest` and wire up a `build` script to compile our code using the babel “latest” preset when source files change. This means those using our package can use it in any version of JavaScript even though we are using the latest syntax for our source code.

Set up compilation of source code using babel with npm scripts

angular-cli

Generating components with the Angular CLI allows for scaffolding applications quickly. Learn what will be generated for you and how to generate quickly with shortcuts in the desired directory.

Generate components with the Angular CLI

Angular is a development platform for creating applications using modern web standards. Angular includes a wealth of essential features such as mobile gestures, animations, filtering, routing, data binding, security, internationalization, and beautiful UI components. It's extremely modular, lightweight, and easy to learn.

angular

Getting started with angular development can be difficult, with a lot of moving parts. Allow the Angular CLI to handle those complexities so you can focus on creating great applications.

In this lesson you will learn how to install the Angular CLI from npm, create a new application, serve the new application in the browser and edit it with live-reload.

Install the Angular CLI to Create and Serve an Angular Application

Gulp is a toolkit for automating painful or time-consuming tasks in your development workflow, so you can stop messing around and build something.

gulp

What is already a nice workflow using Gulp, Browserify, Watchify & Browsersync to enable auto rebuilds & live browser reloading can be further improved by adding Babelify. A simple wrapper around the popular transpiler Babel, Babelify can ‘transform’ source files as they pass through our stream to enable certain Javascript features not yet available in the Browser or Node. We end the lesson by looking at how to generate & extract sourcemaps using `exorcist`.

Gulp and Browserify - Adding Babel & Source Maps

Babel is a compiler that lets us right future JavaScript not yet fully in browsers (ES6 / ES2015, ES7 / ES2016, etc) and transpile it back into code that can be used now. We'll walk through installing babel, writing some future JS syntax, transpiling it, and running it in a browser.

**This lesson is out of date and uses an older version of Babel.**

Writing next generation JavaScript with Babel 5 (out of date)

Webpack loaders are how you tell webpack to resolve your dependencies and you can use a loader built for the babel transpiler to easily enable ES6 code in your project. Full sourcemap support is also available using webpack's devtool property.

Webpack Loaders, Source Maps, and ES6

In this lesson we will our `UiModule`, that has a `LayoutComponent`, `HeaderComponent` and `FooterComponent`. 

We generate `UiModule` by running the following command:
```
ng generate module ui --module app
```

This generates the new module and imports it in our `AppModule`.

We'll create the `LayoutComponent` using:
```
ng generate component ui/containers/layout
ng generate component ui/containers/header
ng generate component ui/containers/footer
``` 

We update our `AppRoutingModule` and add this component to our first route to make it visible. 

The `HeaderComponent` and `FooterComponent` are referenced in the LayoutComponent and we implement the actual templates!

Create Application Layout with Components in an Angular CLI Project

In this lesson we will add the `ProductModule`, where our actual application code will live.

```
ng g m product --routing
``` 

We will add 2 routes to `AppRoutingModule`,  the first is a redirect route that redirects any unhandled paths to `products`. The second route is the actual `products` route, that 'lazy-loads' the `ProductModule`.

We use the `ng` command to create the `ProductListComponent` and `ProductDetailComponent`, which are so called 'containers components'.

Container components are responsible for fetching data, handling routes and passing data into the 'presentational components' 

We will add 2 routes to `ProductRoutingModule`,  one to each of our new Container Components.

Lastly we will use  `ActivatedRoute` in `ProductDetailComponent` to fetch the `:id` from the route.

Create Container Components for Retrieving Data in an Angular CLI Project

In this lesson we will create the presentational components for the product list and detail pages. These components define how the data is displayed and are being referenced from the Container components.

The new components are `ProductsComponent` and `ProductComponent`.

After using `ng generate` to generate these components, we will update the `ProductListComponent` to invoke `ProductsComponent` and pass in our local `products` array.

In `ProductsComponent` we loop over each of the items we get from the `@Input() products` and pass each one into our `ProductComponent`.

The `ProductComponent` has 2 `Inputs()`, one for the `Product` and a `boolean` that toggles showing the product details. This is useful because don't want to show product details in the list view.

After the `ProductComponent` is implemented the last step is to reference it from the `ProductDetails` container component. 

Create Presentational Components for Displaying Data in an Angular CLI Project

In this lesson we will create the `ProductsService` that is responsible for the interaction with our API. 

We will inject the `HttpClient` that we get from `@angular/common/http`. To make this working we need to import `HttpClientModule` in our `AppModule`.

We define a `getProducts` and `getProduct` method so we can get a list of products and an single product which we will use in respectively the `ProductList` and `ProductDetail` components. 

In both components we will use the `ngOnInit` lifecycle hook to invoke the methods on the service, and retrieve the data by subscribing to it. 

[Link to product api used in lessons](https://github.com/beeman/egghead-products-api)

Create an Angular Service to Retrieve Data from an API 

In our 'container components' we use the `ngOnInit` lifecycle hook to subscribe to our service. While this works, there is a downside: the components get loaded before the data is available, which results in that we show empty components. This is particularly visible on slow connections.

To fix this we create a `ProductsResolver`, and implement the `resolve` method that fetches the data from the service. In `ProductRoutingModule` we add the `resolve` property to our route, and add make the `ProductsResolver` resolve and store the data in the `products` property.

Inside our `ngOnInit` in `ProductListComponent` we can now subscribe to the route data, which makes the usage of the service in this component obsolete.

We do the same for the `ProductDetailComponent`. After this there are no longer empty components, the router will not navigate after the data is retrieved.

Create Angular Resolvers to retrieve the product data from the Service

In this lesson we will install the latest version of Angular CLI and use the `ng new` command to scaffold out the application.

Scaffold a New Angular App using Angular CLI

In this lesson we will add Bootstrap to our project. This allows us to focus on building our app without having to spend too much time writing custom CSS.

We will use grab the URL too the Bootstrap CSS from [bootstrapcdn.com](https://www.bootstrapcdn.com/)  and add it to our project by adding a `@import url('')` statement to `src/styles.scss`.

Add Bootstrap to an Angular CLI Project

The default Angular CLI configuration generates components that consist of 4 files. The component class, an HTML template, a stylesheet and a spec file that contains the unit test.

In order to keep our components concise we  update our `AppComponent` and move the template and style from an external file to inline. This allows us to delete the 2 external files. 

We can configure our project to generate the template and the style 'inline' by default.

To do this we run the commands:
```
ng config schematics.@schematics/angular.component.inlineStyle true
ng config schematics.@schematics/angular.component.inlineTemplate true
```

The changes are made to `angular.json` in the project root.


Configure Defaults for Generating Code with Angular CLI

A default Angular application ships with two default environment files that can store constants that are different for each environment, one for development and the other for production.

We will define the `apiUrl` constant in both development and production environments. 

The value for development is  `http://localhost:3000/api` and the value for production is `https://egghead-products-api.now.sh/api` .

In `angular.json` we can find a `configurations` object where our `production` build is defined. We can see that in a production build, the `environment.prod.ts` will replace `environment.ts`.

[Link to product api used in lessons](https://github.com/beeman/egghead-products-api)

Topics

Instructors

Content Type