Your own Component-based JavaScript Library
Tags: javascript, programming, beginners, webdev
Published: 2020-09-14 08:28:42

What do React and Angular have in common besides being two of the biggest frontend web development frameworks/libraries out there?

*They both are component-based!*

In this article, we will create a simple frontend library that uses components with good old plain JavaScript. This may help us understand components a bit more and also sharpens our skills in plain JavaScript.

###Prerequisites

Before we can dive into the JavaScript part of this article we need to set up our project structure. For that we create a new folder called *component-library* and some more subfolders and files:

```Shell
$ mkdir component-library
$ cd ./component-library
$ mkdir lib style components
$ touch index.html index.js ./style/styles.css
```
Next up we need to fill out our HTML and CSS files like this:
```HTML
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
  <link rel="stylesheet" href="style/styles.css">
</head>
<body>
  <main id="app"></main>
  <script type="module" src="index.js"></script>
</body>
</html>
```
```CSS
body {
  background-color: cornflowerblue
}

a {
  text-decoration: none;
  color: white;
}

.article {
  border: 1px solid cornflowerblue;
  margin: 0px 2px 5px 2px;
  padding: 10px 15px 15px 15px;
  background-color: white;
}
```
Now we are all set up and ready to write some JavaScript.

###The library called Eszett

I like to start by pretending the library already exists. Because of that, the first thing we need to focus on is *index.js*.

At the very top of the file we need to import our library and then instantiate a new application:
```JavaScript
// All our imports are here
import ß from ‘./lib/Eszett.js’;
// Initialize app
const app = new ß('app');
```
This code will throw an error because we did not export anything from our *Eszett.js*. In this file, we need a class called **ß** with a constructor that takes in a **selector** as a string and export it. So first of all we need to create a file like this:

```Shell
$ touch ./lib/Eszett.js
```
The content of this file should look like this:
```JavaScript
class ß {
  constructor(selector) {
    this.eszettElement = document.querySelector(`#${selector}`);
    console.log(‘Eszett initialized!’);
  }
}
export default ß;
```
If you run your application now we won’t get an error anymore and the text ‘Eszett initialized’ should appear in your browser’s console. But so far we don’t do that much with our code. Let’s change that by implementing the possibility to register components in our application.

###Components
For this to work we need to implement two things:
a field to store all the registered components
a *registerComponent* method
First of we add the following line in the constructor right above the *console.log*:
```JavaScript
this.components = {};
```
The plan is to register all the components in this field as key-value-pairs. To do that we need to add the following method below the constructor:
```JavaScript
registerComponent(component {
  this.components[component.name] = component;
}
```

Now we can register components in our application. The registration will take place in the *index.js* right below the initialization of our app. Our first component will be a **MenuComponent**. This will be a two-step process, first, we import the component and then we register it after the initialization of the app.

After doing that our *index.js* should look like this:

```JavaScript
// All our imports are here
import ß from ‘./lib/Eszett.js’;
import MenuComponent from ‘./components/MenuComponent.js’;
// Initialize app
const app = new ß(‘app’);
// Adding our Components to the App
app.registerComponent(MenuComponent)
```
At the moment our application will throw an error because we don’t have the **MenuComponent** yet, now we go ahead and create that by adding a new file like this:
```Shell
$ touch ./components/MenuComponent.js
```

In this file, we will import our not yet existing *Component.js*, so that we can create a new component. After that, we need an *HTML-Template* and last but not least the component itself. This is how it should look like:

```JavaScript
// Import statements
import Component from '../lib/Component.js';

// HTML-Template
const menuTemplate = (state) =>`
  <header>
    <h1>
      <a href="#/posts">${state.name}'s Blog</a>
    </h1>
  </header>
`;

// Component
const MenuComponent = new Component(
  'menu', 
  {
    name: 'Jakob'
  },
  menuTemplate);

export default MenuComponent;
```
Let’s take a closer look at the *HTML-Template* first. It is a function that returns a [template literal](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) (template string) and gets the state of the component passed in as a parameter. In line 8 we see that this state gets used to dynamically render the name of the blog.

Taking a look at the component itself we see that it gets passed in three parameters. The first parameter is the name of the component itself, the second parameter is an object with a single attribute called name. This is the state object we pass on to our *menuTemplate* which is also our last parameter.

For all of this to work, we need to implement our *component.js*. First, we need to create a file like this:

```Shell
$ touch ./lib/Component.js
```

The implementation of our component is straight forward. We need a constructor that takes in three parameters and we need a function that calls our *HTML-Template-Function* and returns its result. At the end it should look like this:

```JavaScript
class Component {
  constructor(name, state, template) {
    this.name = name;
    this.state = state;
    this.template = template;
  }

  view() {
    return this.template(this.state);
  }
}

export default Component;
```
Now our page won’t show any error but it won’t display our **MenuComponent** either.

###Rendering
We can create a component and register it in our application but we can’t display the components HTML. Before we tackle this problem I want to add a **PostsComponent** to our application so that we can render two components at the same time.

For that we need to register it like this:

```JavaScript
// All our imports are here
import ß from './lib/Eszett.js';
import MenuComponent from './components/MenuComponent.js';
import PostsComponent from './components/PostsComponent.js';

// Initialize app
const app = new ß('app');

// Adding our Components to the App
app.registerComponent(MenuComponent);
app.registerComponent(PostsComponent);
```
Create it:
```Shell
$ touch ./components/PostsComponent.js
```
And implement it like that:
```JavaScript
import Component from '../lib/Component.js';

const postsTemplate = (state) => `
  ${state.posts.map(post => `
    <li>
      <div class="article">
        <h3>${post.title}</h3>
        <p>${post.text}</p>
      </div>
    </li>`).join('')}
`;

const PostsComponent = new Component(
  'posts', 
  {
    posts: [{
      title: 'My first blog post',
      text: 'This is my first blog post EVER, its awesome!'
    },
    {
      title: 'Writing my own component library',
      text: 'In this article I want to share with you my experience on how to write a component library!'
    }],
  },
  postsTemplate
);

export default PostsComponent;
```
For the rendering to work we need to update the [DOM](https://en.wikipedia.org/wiki/Document_Object_Model) by calling the view method of our components and inserting the returned HTML into the already defined *eszettElement*. The described behavior should be one method of our *ß* class and be called inside our *registerComponent* method. This is the final implementation of our class:
```JavaScript
class ß {
  constructor(selector) {
    this.eszettElement = document.querySelector(`#${selector}`);
    this.components = {};
    console.log('Eszett initialized!');
  }

  registerComponent(component) {
    this.components[component.name] = component;
    this.updateView();
  }

  updateView() {
    if (this.components) {  
      let mergedViews = '';
      Object.keys(this.components).forEach(key => {
        mergedViews += this.components[key].view()
      });
      this.eszettElement.innerHTML = mergedViews;
    }
  }
}

export default ß;
```
The *updateView* method first checks if there are any components registered. If that is the case it iterates over all the components and calls the *view* method of every single one of them. The returned HTML will be merged and set to the *innerHTML* of the *eszettElement*. If everything worked out your final page should look like this:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/i/q3h648npgtqjn8bjh93b.png)

###What could be next?

We just created our small library called **Eszett**. We can create components that contain isolated state and their own HTML-Templates. These components can be registered and rendered at the application level.

There are a few more features we could add. For example, a Router that displays certain components on certain routes or the possibility to nest a component inside another component and pass down the state.

Just try out adding new features to this to sharpen your JavaScript skill and while you are at it, have fun!

As always you can find the code for this project on my [GitHub](https://github.com/JakobKIT/eszett-lib).

<span>Photo by <a href="https://unsplash.com/@syinq?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Susan Yin</a> on <a href="https://unsplash.com/s/photos/library?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></span>