
# What is an Anchor Link?
According to [doc.sitecore](https://doc.sitecore.com/xp/en/users/100/sitecore-experience-platform/create-an-anchor-and-link-to-it.html#:~:text=An%20anchor%20is%20an%20HTML,the%20middle%20of%20another%20page.) an **Anchor Links**

>**is an HTML code that is used as a bookmark to create a link to a particular section within a page**. For example, it could be a Back to top link that takes the user to the top of the current page, or it could be a link to a section in the middle of another page.

So, it's like bookmarks. You click on an anchor link and you get moved there automatically. It's pretty cool and I always found it very useful as well. Like in [Wikipedia](https://en.wikipedia.org/) pages, the summary made with anchor links helps you to find the exact part that you want.

And my idea was to have something like that in our blog as well. In the future, we will have big articles with multiple parts, and the anchor links are a good way to travel fast through the article.

# How Anchor Links Works 
To use an anchor link you need a `<a>` tag to serve as the redirector. But the key thing is the *href* passed to this tag, which is the ID of the item that you want to jump to. So if you want to go to the title **Why not use replaceAll()** from this you would need to add an id to this title inside its HTML:

```html
<h1 id="why-not-use-replaceall"> Why not use replaceAll() </h1>
```

So our `<a>` tag would look something like this:
```html
<a href="#why-not-use-replaceall"> Link to title </a> 
```
 Then, if you click on this tag, the website would search for an element with this id and scroll to it, turning your URL into.
 `https://backtopixels.vercel.app/blog/how-to-build-an-auto-gerenated-summary#why-not-use-replacealll`
 
 It's very simple to understand right? The browser just searches for the element with the same ID as the link.
 
 # Automating  Titles IDs
 Of course, you wouldn't add ids and links to every title that you have on your page, you can automate that very easily.
 
 I use [*react-markdown*](https://www.npmjs.com/package/react-markdown) to make the MarkDown transcription to HTML (you can read more about it in [this](/blog/the-way-we-do-markdown-transcription) post). With this package, you can actually change the returning element to each translation. So I can change every *h2* to an *h1* or add more styles, classes and etc. To add the IDs I could just format the text inside the *h1* and added it as the ID of this element, but you don't need to. You can just add the [remark-slug](https://www.npmjs.com/package/remark-slug) package as a plugin to the *react-markdown* and it does all this for you.
 
 ```jsx
<ReactMarkdown 
	   remarkPlugins={[remarkSlug]}>
	{yourMarkDown} 
</ReactMarkdown>
```
 
 That is half the work done!
 
 # The Summary component
 What the summary component will do is receive your markdown (you can receive the HTML as well if you want), find all the titles, separate them, format the links, and create a list of `<a>` tags with the name of the title as it's text, and the name formated as the link:
 ```jsx
<a href={`#${link}`}>{name}</a>
```
And then everything just works!

# Getting Titles and Links
As I said before, our component will receive the entire markdown to get the titles. To do so, we will separate all the text by its line breaks with `split("/n")`, and then search for the lines that start with *#*.
```js
const textLines = content.split('\n');
const titles: string[] = [];

textLines.map(((line: string) =>{ // for every line of the content
	if(line.startsWith("# ")){
 		titles.push(line); // get the line that starts with "#"
	}
}));
```

Now that we have every title separated we can format it to get the link. As I'm using typescript, I decided to transform it into an *interface*
```ts
interface TitleAnchorLink{
	href: string,
 	name: string,
}
```

Now we will declare two functions, one to **format** the link and another to generate the *TitleAnchorLink*:

```ts
const formatTitleLink = (title: string): string =>{
	let link = title.slice(2).toLowerCase().trim().split(" ").join("-");
	link = removeSymbolsFromLink(link);
	return link;
}
```
Let me explain, this **formatTittleLink** function: first we *slice* the first two characters from the line, because those characters are `# `, the declaration of the title in markdown, and we don't need it. Then we remove all extra spaces with `trim()` and finally we replace all spaces by trace (-). The reason why I used `split(" ").join("-")` instead of `replaceAll(" ", "-")` is because *replaceAll* is not supported in all browsers, and not supported by the Vercel server. The *split* separates our string in a list by every space, then the *join* transforms this list into a string separating every item by *-*.

Another thing to explain is this function *removeSymbolsFromLink*, as you may notice URLs don't have certain characters, like question-marks, exclamations, brackets, math signs and etc, that may appear in our titles. So we create a list of characters that should be removed, iterate through them, and replace the character with a blank space. 

```ts
const symbolsToRemove = ["?", "/", "@", "+",".", "!", "%", "$", "(", ")", "*", "<", ">", "&"];// you can add more if you want
const removeSymbolsFromLink = (link: string): string =>{
	symbolsToRemove.map((symbol: string) => {
		link = link.split(symbol).join(""); //remove symbol from the string
	});
	return link;
}
//This function still has room for improvement
```

Now we can use those functions in our *getTitleLinks*:

```ts
const getTitleLinks = (titles: string[]): TitleAnchorLink[] =>{
	 const titleLinks: TitleAnchorLink[] = [];
	 titles.map((title: string) =>{
		 const link = formatTitleLink(title);
		 title = title.slice(2);
	 	titleLinks.push({name: title, href: link});
	 });

	 return titleLinks;
}
```
Let's review what is been done.
1. Separate every line of the text
2. Get the lines that start with *#*
3. Remove the *#*, replace spaces with *-* and remove the unwanted sign
4. create the object *TitleAnchorLink* with that information

obs: I'm also removing the `# ` from our title itself, so it becomes just the title without MD notations

Now we have all the information we need to execute our Summary Component
```tsx
const AutoGeneratedSumarry = ({content}: AutoGeneratedSumarryProps) =>{ 
	const titles = getPostTitles(content);
	const titleLinks: TitleAnchorLink[] = getTitleLinks(titles);


	if(titleLinks.length == 0) return <></>;

	return(
		<div className="post-sumarry">
		<h3>Summary</h3>
			<ul>
				{titleLinks.map((anchor: TitleAnchorLink, index: number) => {
					return (
						<li key={index}>
							<Link passHref href={"#" + anchor.href}>
								{anchor.name}
							</Link>
						</li>
					);
				})}
			</ul>
		</div>
 	);
}
```

Let's see what this component does.
- First, get the TitleAnchorLinks using those cool functions
- Then, check if the list of Title links is empty, if they are, return an empty component
- Finally, for every link in our list, return an element with the content as the name and the link as a # followed by the formated link.

And it's done!

---
I added some CSS and the end result is this one

![gif-summary-result](git-summary-working.gif)

Of course, that exist some cool improvements that you can do, like an open and close animation, subtitles indented inside titles, and more. 

If you have any questions you can send them to me, Just open my profile ([Renato](/team/renato)) and send me on any social media.

There are many new things in this blog that I implemented since the last update, and this summary was one of those. I will write a post about the new stuff in the future.

Bye Bye!👋👋

Implementing An Auto-Generated Summary


In this post, which is kind of a tutorial, I will show you how I [Renato](/team/renato) implemented this blog's dark theme system, how to implement it on your own with CSS only. How CSS variables work and why use CSS only for it instead of a simples package.

# Understanding CSS Variables
Like in any real programming language you can declare variables and use them, even not been a programming language you can declare variables in CSS as well. 

A CSS variable is declared using double-dash `--name` plus a semicoma and then the value of this variable:  `--example: blue;`.

These variables are created inside scopes and can only be used for those inside that scope. So if you create your variable in a `.blog-page{}` scope, it will only be available for its children.

Using a CSS variable is like calling a function `var()` with the parameter being the name of your variable. 

Look this example of the scope and use of a variable:
```css
.cool-page{
	--best-color: #382F60
}
.cool-page h1{
	color: var(--best-color)
}

.another-page h1{
	color: var(--best-color)
}
```

In the first `h1` use (*.cool-page h1*) the variable will work perfectly. But in the second one (*.another-page h1*) it will not work. Because the variable is only declared in the `.cool-page` scope.

CSS variables can be anything:
- Colors;
- Sizes;
- Fonts;
- Borders;
- Shadow;

And any kind of CSS value that can be used in CSS can be stored in variables to be used later.

When I started this website I created all my variables in the `:root` class, so every other element could use it (you can use HTML or body tag instead as well).

Another thing to notice is that you can **overwrite** variable values in another CSS element, so if you declare `--cool-color` in the *root* element, you can overwrite it inside of *body* and change the value for all those which are inside of it.

Those variables are very useful if you want to test palettes, change fonts easily, etc. So even if you are not going to a *dark-theme* implementation, I recommend you to use CSS variables.

# Making Dark Theme With CSS Only
So, you can define and use variables in all your code. If you define it all in the `:root` you can use it anywhere. Changing only one variable you will change the value for all the elements that use it.

The dark theme with CSS only is based on this idea:

> Build all your styles with variables, then, when you change the theme, change the value of all the variables.

To change these variables we can define the variables in the `body{}` element. Define your variables there and create a `body.dark{}` element as well and overwrite all the variables there:

```css
body{
	--cool-color: #382F60;
	--font-color: #2d2d2d;
}
body.dark-theme{
	--cool-color: black;
	--font-color: white;
}
```

The idea is to change the *body* class depending on the theme that you want to use.

---
If you declare all your variables and overwrite them in the `body.dark` you can already test it by adding a *class* to the *body* in your browser.

# Changing Themes Inside Next.JS
There are problems changing CSS inside *Next-JS* thus it's a server-side rendering, but it's still possible.

But first a context: I created a theme switcher on my page, and the code that I will explain now is inside this component.

---
Thus we are using Next-JS, we need to set some *useState* to manage the state of the theme. Then we can create a simple function to change the theme depending on the theme that is already set.

```jsx
 const [theme, setTheme] = useState('light-theme');

 const switchTheme = () => {
	 if(theme === 'dark-theme'){
		 setTheme('light-theme');
		 return;
	 }
	 else{
	 	setTheme('dark-theme');
	 }
 }
```

But until here we are just saving this value and not applying it in the class of the body. To do so, we will need a `useEffect()`. This *useEffect* has two reasons to be here.

The first is to let us know if the website is loaded, thus this function only executes when the website finishes the pre-load.

And the second is to know if the code is being executed in the server (during the server rendering) or during the client access.  That's why we need to have a **loaded** state. We will set this **loaded state** as *true* if the  `useEffect` execute and then we will pass to the *body* the class of the theme that we are at.

```js
 const [loaded, setLoaded] = useState(false);


 useEffect(() => {  // if we are at the client side,
	 setLoaded(true); //  set loaded as true
	 document.body.className = theme; // and add the class to the body
 });

```

If you don't use the `useEffect`, the framework might don't build the project or even don't run the page.

---
Now, when constructing your *theme switcher* you need to use this *load* variable to check if is everything allright to render (if we are at the client and if all the page has already been rendered):

```tsx
 return(
	 <div onClick={() => switchTheme()}>
		 {
			 loaded?
				[themeSwitcher]
			 : <></>
		 }
	 </div>
 )
 ```

# No Colors on Loading Problem
Thus, the code to decide the theme that is active only executes when the page loads. You may have a problem with no defined colors when your website starts to load (before the "choose theme" function be executed). To fix that you have two options:

## Option 1
Instead of creating two classes for the body `.dark-theme` and `.light-theme` you can create only one and add or remove it on the *change theme* code, instead of changing from one to another. In this way, the no-class colors will be loaded instantly.

## Option 2
You can define *general-colors* (that don't change) and main colors in the `:root` element. In this way, these *general-colors* will be loaded on start and overwritten if needed after the *change theme* code execute. This helps if you want to add more themes in the future and it's the option that I choose, mainly for readability.

```css
:root{
	--header-color: blue;
}
body.light-theme{
	/*just uses the defined in the :root*/
}
body.dark-theme{
	--header-color: black;
	/*overwrite the root color after the loading*/
}
```


# Other Methods
Of course, you could  use a package, but personally I always rather do it myself instead. In this way, you learn more about your tools and how things work.

Anyways, it's that. Any questions or advice you can send me on my [Twitter](https://twitter.com/nerat0). I always post some updates about this blog there as well. See ya!


The Easiest Way to Achieve Dark-Theme


All the posts of this website are written in `.md` files, which is a much much better way to write content without losing your mind with HTML opening and closing tags. Websites such as Medium, LinkedIn, and GitHub use this Markation language to save and write their posts and **READMEs**. So nothing better to use it as well. The Mark-Down also provides an easy way to write for a non-programmer person, so it's very good for our future teammates as well. Thus this is a static website all the mark-down translation happens in the build time, instead of in the "consuming" time. That is, this work is done by the server when a new version of the website comes out, and not by you, the lovely user. 

# Configuring the Mark-Down file
The `.md` file is configured by a header, where you can declare variables to use later, those variables can be anything, lists, numbers, string, etc. The configuration of this post looks something like this:

```yaml
---
title: 'The Way We Do MarkDown Transcriptions'
date: '09/02/2022'
author: 'renato'
cover_image: 'cover'
excerpt: "Explaining how our .md to HTML works and the new features I just implement"
categories: [BLOG, DESIGN, PROGRAMMING, NEXTJS]
---
```

The title, date, excerpt are very auto-explanation. The author is just a key to getting its info later and the categories the same (the upper case is just something for visualization). The cover image is very simples as well, is the name of the image that will be used as a cover. You can read more about the way we deal with images in [this post about it](/blog/default-images-and-our-images-architecture). 

After this header comes to the post itself. We use [grey-matter](https://www.npmjs.com/package/grey-matter) to separate the content and the header variables. Then we use a `createPost()` function to get the detailed information of the author and each category.

# The Transcription It Self 
In the first versions of this website, we used to use [markdown-it](https://www.npmjs.com/package/markdown-it) to transform `.md` files into HTML. But MarkDown-it has some problems, that is, fewer features.  MarkDown-it doesn't provide a replacement of translated HTML (so you cant use code highlight in code block). This package doesn't provide many other `.md` translation like
- check-boxes
- tables
- footer notes

Now, for the other side, [react-markdown](https://github.com/remarkjs/react-markdown) provides all of it and much more. Thus react-markdown uses remark as an API and it has some kind of modular separation, it provides the addition of plugins, such as remark and rehype plugins. React-markdown also provides a way to replace the HTML translated with functions. So if I want to change every link that has my name to a golden and shines name, I actually can.

# Amazing Possibilities
Using this kind of replacement I was able to replace every code block with a Prism Syntax Highlighter React element that can provide us with those beautiful code blocks. Or for example the replacement of every image by a zoomable image element that I created. Or even the stylization of our check-boxes. There are many other things to replace yet, and the code of it is very ugly but it is stills very useful in this case. 

I also realized some days ago this plugin thing of the package and added some of those to our project. Like tables and footer-notes. I still need to test it on smartphones, etc but it is already working[^1] . The go-to footer not is working fine, but the come back doesn't for no reason. Maybe I implemented something wrong, but it should work. The tables thing was something that I was missing up for future posts, and now I don't.

We still using grey-matter for the post card, thus the post just needs simple transcription.

---

Now, here is a table example to test it out:

Feature | status
-------| ------
Tables | done
Footer-notes | done
Hover-teammate-name | stylizing
zoomable-images | cool but not perfect
Dark-theme | don't have any idea
News-letter | what? how?
Writer/post info | Designing

# More Slylish Quotes
Another thing that I added thus those ones, was a property style for the `<blockquote>` component. That goes like this:

>Now I've heard there was a secret chord
That David played, and it pleased the Lord
But you don't really care for music, do you?

I'm not sure about this grey background, but I think it's ok!

# RSS Feeds
I still messing around with this, but anyways. Now we have an RSS feed generator script. So you can get its link and paste it into any Feed reader to have these posts in your App. It still with some images and date problems, but it works, and it's very cool.

* [x] RSS feeds and links component

Also created a simple component to hold these links at the end of each post and blog page. as you can see here ⬇️ 

[^1]: See?



The Way We Do MarkDown Transcriptions



From now on, if you share one of our posts on *social media* it will look something like that:

![post-in-twitter](post-in-twitter.webp)
You can read the post of the image [here](/blog/reunion-0-1).

It also works in *instagram*, *whatsapp*, *facebook*, *Discord* and *LinkedIn*.

I have never known how this kind of interpretation was made. The only thing like that I knew was the RSS system that many podcast providers use. The RSS is a bunch of HTML tags with all the information of the podcast. First I thought that this cover image and description was based on RSS ass well. But no. It's all **Meta Tags**.

# More About Meta Tags

The only thing that I knew about meta tags is that they could change the *favi.icon*, the bar color, and the title of the website. But searching a little bit about meta tags to fix a Next.Js bug, I came across another kind of meta tags, with properties like *og* (OpenGraph) and *twitter*.

This *OpenGraph* protocol was created by facebook and:
> enables developers to integrate their pages into Facebook's global mapping/tracking tool Social Graph.
according to the [Facebook Platform Wikipedia](https://en.wikipedia.org/wiki/Facebook_Platform).
Over time more websites and social media start to use it as well.

# How I implemented it here

First I added a simple `<head>`component with general metatag info in the *_app.tsx* file. Info like:
- Creator
- Theme-color
- copyright
- og:locale

Since this kind of value doesn't change through the website.

---

And in every single page (Home, Team, Blog) I added more additional info like the description of the page and the title.
 
But the cool thing is on the *post* page. Each post, when generated as a static page, generates its meta tags with all its information. Sucha as:
- post Description
- post author
- keywords
- All the og tags 
    - type
    - url
    - title
    - image
- all twitter tags
    - card type
    - image
    - title
    - description
    - creator
    - domain

And more not so important tags, like height and width of images, etc.

Just using this it's possible to implement the cool share card in social Media. Look how my post tags look like now:

![post-meta-tags](post-meta-tags.webp)

The only thing that give me some problems was the Twitter postcard. I don't know why, but Twitter only accepts when you put the post image coming from the internet, and not local. I will make some new tests to see if this deduction is correct.

# New features in this website

Since the last update ([reunion 0.1](/blog/reunion-0-1)) I made some new things here. But the coolest and more important is the animations.

So yes, we finally added the Header, but the cool part is the animation that I, kind of, found. I was creating a *Media Query* for smartphones and then, when I was adding a transition of states, the VS code start to suggest some [Bézier curvs](https://en.wikipedia.org/wiki/B%C3%A9zier_curve) as animations transition parameters. I tested someones and liked this one that I'm using now. After this, I study some animations from [codepen](https://codepen.io/) and made this one. Look how the header is looking great:

![header-animations](header-animations.gif)

I had some new animation ideas to implement in the future, so wait for it!

4

Posts in the category

Implementing An Auto-Generated Summary

The Easiest Way to Achieve Dark-Theme

The Way We Do MarkDown Transcriptions

Discovering Meta tags + Website Updates

4

Posts in the category Next.JS

Implementing An Auto-Generated Summary

The Easiest Way to Achieve Dark-Theme

The Way We Do MarkDown Transcriptions

Discovering Meta tags + Website Updates

Posts in the category