
```info
This document is a WIP, to be a good reference point for folks starting out
their journey in front-end web development.  
More content will be added soon.
```

## HTML

### DOCTYPE declarations

The required `<!DOCTYPE html>` preamble found at the top of all documents.
Prevents the legacy [Quirks Mode](https://developer.mozilla.org/en-US/docs/Web/HTML/Quirks_Mode_and_Standards_Mode).

In practice? Include it in all your HTML for fully-compliant markup:

```html
<!DOCTYPE html>
```

## HTML tags

### Anatomy of an HTML tag

Let's take the following element as an example:

```html
<a
  href="https://example.com"
  target="_blank"
>
  Example
</a>
```

```html 1-4
<a
  href="https://example.com"
  target="_blank"
>
  Example
</a>
```

👆 This is the opening tag.

```html 6
<a
  href="https://example.com"
  target="_blank"
>
  Example
</a>
```

👆 This is the closing tag (some elements may be self-closing, e.g., `<br />`).

```html 2-3
<a
  href="https://example.com"
  target="_blank"
>
  Example
</a>
```

👆 These are the attributes.

```html 5
<a
  href="https://example.com"
  target="_blank"
>
  Example
</a>
```

👆 This is the content.

### Importance of semantic HTML



### Main HTML elements

#INCLUDE_TABLE{web-dev-cheatsheets/main-html-elements.csv}

### Semantic HTML elements

#INCLUDE_TABLE{web-dev-cheatsheets/semantic-html-elements.csv}

### Formatting HTML elements

#INCLUDE_TABLE{web-dev-cheatsheets/formatting-html-elements.csv}

### General/functional HTML elements

#INCLUDE_TABLE{web-dev-cheatsheets/functional-html-elements.csv}




Well, my friends, it's been a while since [my last blog post](/blog/future-of-software-development)
but it's good to be back.
Last one was a bit bird's eye and hand-wavy, so on this occasion let's get practical.

> **Note**: This one goes out to Or Bendel from my team, with whom we discussed this useful feature 😊

```info
As with every one of my blog posts, if you want the _tl;dr_
feel free to go over the orange "Key Takeaways" sections.
```

Today, I wanted to share a quick workflow that I think can help developers (especially ones who aren't prone to scrutinizing their changes before committing)
to help make sure no undesired changes are pushed.  
I will be addressing a common pain point for developers -
how do I avoid accidentally committing or checking in so-called DNC (Do Not Commit) comments/phrases
in source code?  
Leaving unintended snippets of code in code reviews can not only require redundant code review rounds and add "noise" to the code review process,
but also cause unintentional changes to be checked in at times (I remember the awkwardness of slipping in a naive "Test!" `console.log` earlier in my career).

So, let's start with the question - what are DNC messages anyway? These may appear as comments
that you add while developing to remember to go back and change something.

For example:

```js
function doStuff() {
  console.count("doStuff was called"); // DNC
  // ...
}
```

I often use _"TODO(PR)"_ or _"TODO(DNC)"_ as a reminder to myself to go back and resolve that thing
before publishing a pull request (or, God forbid, before checking in with TFS), but in general this
may be any arbitrary VCS that you use.  
Personally, I prefer to use uncommon expressions so that I can quickly search the code to make sure
I don't actually introduce them in my changes.

In general, when I asked various developers about this issue this is how the conversation went:

```convo
Me: Do you ever add temporary comments for yourself before committing for changes you don't want to introduce to the pull request?
Them: Yeah, I use <X> or <Y>.
Me: And how do you make sure you don't accidentally commit them?
Them: I diff my changes.
Me: So you do it manually?
Them: Yep.
Me: And nothing ever slipped past your scrutiny?
Them: Well...
```

So, we have a problem which seems to require manual solutions using an error prone process that
trips up even the most thorough and diligent developers.
Well, what do _productive_ (see: bored) humans do for problems that require a routine manual step?
They automate it, of course!

![Obligatory [xkcd](https://xkcd.com/1319/) (how could I not?)](https://imgs.xkcd.com/comics/automation_2x.png)

...Oh, how to automate it, you ask? Well, git hooks might be a good option!

```info
I will note that this is a good thing to enforce in your CI (Azure Pipelines, GitHub Actions, TravisCI, etc.).
In fact, Dell have a [GitHub Action](https://github.com/dell/common-github-actions/tree/main/code-sanitizer) that forbids certain words (in this specific case, non-inclusive language)
which is a great use-case for a CI gate!
However, in this case these DNC messages may be "personal", by design, as as you don't want to mix up your DNCs with general TODOs in the codebase,
since you would want to easily search for them to spot your own changes.
For example, I could use _"TODO(PR)"_ for my DNC phrases and you could use _"DO NOT COMMIT"_).
```

```takeaways
- Developers sometimes add temporary comments to code changes which may be accidentally introduced in the code review
- This is often an error-prone process which can be easily automated with git hooks
```

## git hooks

### What are git hooks?

[git hooks](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks#_git_hooks) are a way to "hook" into stages of the git version control lifecycle,
and give the ability to run scripts at certain events, for example before a commit, after a commit or before a push.

Some examples of common hooks are:

- `pre-commit` (before committing): often used for linting/formatting
- `commit-msg` (after submitting the commit message): often used for enforcing styles on commit messages
- `post-commit` (after committing): often used to tag commits

> An exhaustive list can be found [here](https://git-scm.com/docs/githooks#_hooks).

There are server-side hooks which can run on the VCS server, but we'll be focusing on client-side scripts,
which are triggered by local events in your local git repository.

```info
Atlassian have a [great tutorial](https://www.atlassian.com/git/tutorials/git-hooks) about git hooks, which goes much more in-depth than this humble blog post.
```

### Where do the hooks come from?

In general, there are two ways I know of to run hooks:

1.  **Local hooks** which reside in the `.git/hooks` directory in the local git repository.  
     These are scoped to your local repository.

    ```info
    These can be added automatically if you define a so-called git [Template Directory](https://git-scm.com/docs/git-init#_template_directory).
    Whenever you define a Template Directory, it will be used as the "boilerplate" when you run `git init`.
    By default, when you `git init`, your local repo should contain sample commit hooks in the `.git/hooks` directory,
    with hooks containing a `.sample` file extension.
    The `.sample` extension actually prevents them from being actually registered/installed (once removed, they should run normally).
    by git as real hooks.
    ```

1.  **Global hooks** which you can configure in one place which git will search for, regardless of the local repo you're in (useful for a central location of all your git hooks)
    ```info
    **Notes:**
    - From my experiments, these seem to override the local hooks.
      i.e., instead of looking at the local hooks, git will only use the global ones.
    - `core.hooksPath` was introduced in [version 2.9](https://github.com/git/git/blob/master/Documentation/RelNotes/2.9.0.txt#L127-L128)
      so check whether your git version supports it (run `git --version`)
    ```

There is also the option of using local hooks with **symbolic links** (symlinks) to the centralized hooks location.
As mentioned, using Template Directories you can define the skeleton for new git repos, and you could theoretically define
symlinks to your global hooks.
This is a more "explicit" approach, which may be preferable to some.

In essence, we can boil the options down to:

![](/git-hooks/git-hook-options.png)

I chose **option C** (global hooks) for my workflows, because I have a `dotfiles` folder containing all the shell stuff I like to configure
for my different machines (I have a MacBook, a Lenovo laptop, occasionally a VM/desktop) and [GitHub Codespaces](https://github.com/features/codespaces)
(did I mention Microsoft is the greatest company in the world?).  
Within my `dotfiles` repo which I take "with me" across machines and use symbolic links to reference, I have a directory for
git hooks. I assume that there are no project-specific hooks, since they would otherwise override those.

In general, I would advise that things you wish to enforce for changes happen in your CI,
for example enforcement of linting, style guides etc., as git hooks are a "client" mechanism and in general
any developer can override those (for example with `git commit --no-verify`).

### Setting up global git hooks

The git configuration `core.hooksPath` ([link](https://git-scm.com/docs/git-config#Documentation/git-config.txt-corehooksPath)) controls
the directory git uses for finding the hook to run.

For configuring the global hooks directory (I chose `/etc/git/hooks` for this example) you can run:

```bash
git config --global core.hooksPath /etc/git/hooks
```

```info
**Note:** on UNIX systems you'll need to make the script executable (e.g., `chmod +x /etc/git/hooks/pre-commit`)
```

```takeaways
- Git hooks are a mechanism for triggering a script to run at certain points of your git workflows (before a commit, after a push, etc.)
- There are client-side hooks (which run on your machine) and server-side hooks (which run on the machine hosting your repository)
- There are **local hooks** which are scoped to your local repository and **global hooks** which you could leverage for hooks you want to run from any repo
- I chose global hooks for this blog post since they were the ones I found most suitable for my workflows
- You can configure the global git hooks using the `core.hooksPath` configuration
```

## Pre-commit hook to forbid DNC messages

So, going back to our original problem - how do we use git hooks to forbid "Do Not Commit" TODOs?

What I did was a add a `pre-commit` shell script to my global hooks folder (which in the example above was `/etc/git/hooks`,
but in my case was my `dotfiles` repo).

I have prepared a BASH version (which I'll go over in more detail) and a PowerShell version.
Both are available in a GitHub Gist I prepared for your convenience: [link to Gist](https://gist.github.com/guywaldman/235530baff33fb3409c19e5e81b5a206)

Note that you could even use Python if you wanted to.  
e.g., if you were so inclined, your `pre-commit` could look like this (in UNIX systems):

```python
#!/usr/bin/env python

print("Hello!")
```

Also note that **the scripts aren't perfect** - they may leave much to be desired, and I welcome contributions ([tweet](https://twitter.com/guywald) at me!).

### Pre-commit hook (BASH)

The following is the content of my `pre-commit` script.

```bash
#!/usr/bin/env bash

# Forbidden phrases.
FORBIDDEN_PHRASES=("DNC" "DO NOT COMMIT" "TODO(PR)")

# ANSI color codes.
CLEAR="\033[0m"
RED="\033[00;31m"
BLUE="\033[00;34m"

violation_output=""

# Go over the staged changes, and if any of the forbidden phrases is used,
# add an appropriate message to the output.
for forbidden_word in "${FORBIDDEN_PHRASES[@]}"; do
	changed_file_names=$(git diff --cached --name-only)
	for changed_file_name in $changed_file_names; do
		changed_file_content=$(git diff HEAD --no-ext-diff -U0 --exit-code -a --no-prefix $changed_file_name | egrep "^\+")
		if echo $changed_file_content | grep -q "$forbidden_word"; then
			violation_output+="${CLEAR} • ${BLUE}${changed_file_name}${CLEAR} contains ${RED}\"$forbidden_word\"${CLEAR}\n"
		fi
	done
done

# If there are any violations, print the output and exit with an error code.
if [[ ! -z $violation_output ]]; then
	printf "COMMIT REJECTED (DNC violation): see below for details\n"
	printf "$violation_output"
	exit 1
fi

# If there are no violations, exit without an error code.
exit 0
```

**Let's go over it:**

```bash 3
#!/usr/bin/env bash

FORBIDDEN_PHRASES=('DNC' 'DO NOT COMMIT' 'TODO(PR)')

# ...(OMITTED)
```

👆 Here we define the list of forbidden phrases - customize these to your heart's desire.  
You could extract these to a separate file if you were so inclined.

```bash 3-6
# ...(OMITTED)

# ANSI color codes.
CLEAR="\033[0m"
RED="\033[00;31m"
BLUE="\033[00;34m"

# ...(OMITTED)
```

👆 Here we define the [ANSI color codes](https://en.wikipedia.org/wiki/ANSI_escape_code), to get a beautiful colored prompt.

```bash 3-15
# ...(OMITTED)

violation_output=""

# Go over the staged changes, and if any of the forbidden phrases is used,
# add an appropriate message to the output.
for forbidden_word in "${FORBIDDEN_PHRASES[@]}"; do
	changed_file_names=$(git diff --cached --name-only)
	for changed_file_name in $changed_file_names; do
		changed_file_content=$(git diff HEAD --no-ext-diff -U0 --exit-code -a --no-prefix $changed_file_name | egrep "^\+")
		if echo $changed_file_content | grep -q "$forbidden_word"; then
			violation_output+="${CLEAR} • ${BLUE}${changed_file_name}${CLEAR} contains ${RED}\"$forbidden_word\"${CLEAR}\n"
		fi
	done
done

# ...(OMITTED)
```

👆 Here we go over the new code changes and check if they contain any of the aforementioned DNC phrases.  
If so, we collect the violations into `violation_output`.

```bash 3-11
# ...(OMITTED)

# If there are any violations, print the output and exit with an error code.
if [[ ! -z $violation_output ]]; then
	printf "COMMIT REJECTED (DNC violation): see below for details\n"
	printf "$violation_output"
	exit 1
fi

# If there are no violations, exit without an error code.
exit 0

# ...(OMITTED)
```

👆 Here we check output to determine if the commit can be approved or not (and if not, we print out the violations).

Note that **the exit code is used by git to determine whether the commit can be applied or not.**

### Pre-commit hook (PowerShell)

Below is a PowerShell (`pwsh`, AKA PowerShell 7+) version.
It is similar in structure to the BASH version, so I will avoid going into
detail with this one.

```info
Note that:
- On Windows, you'll need to name this file `pre-commit.ps1` (with the `.ps1` extension),
  though I admit I haven't tried on a Windows system
- On Linux/macOS (yes, PowerShell Core is cross-platform, how awesome is that?), you'll need to add a shebang
  (e.g., `#!/usr/bin/env pwsh`)
```

```powershell
# Forbidden phrases.
$FORBIDDEN_PHRASES = "DNC", "DO NOT COMMIT", "TODO(PR)"

$violations = ""

# Go over the staged changes, and if any of the forbidden phrases is used,
# add an appropriate message to the output.
foreach ($forbiddenWord in $FORBIDDEN_PHRASES) {
	$changedFileNames = "$(git diff --cached --name-only)"
	foreach ($changedFileName in $changedFileNames) {
		$changedFileContent = $(git diff HEAD --no-ext-diff -U0 --exit-code -a --no-prefix $changedFileName | Select-String "^\+")
		foreach ($line in $changedFileContent) {
			if ($line -Match $forbiddenWord) {
				$violations += "$($PSStyle.Reset) • "
				$violations += "$($PSStyle.Foreground.Blue)${changedFileName} contains: $($PSStyle.Reset)"
				$violations += "$($PSStyle.Foreground.Red)${forbiddenWord}$($PSStyle.Reset)"
				$violations += "`n" # PowerShell newline. Yes... I know ¯\_(ツ)_/¯
			}
		}
	}
}

# If there are any violations, print the output and exit with an error code.
if ($violations) {
	Write-Host "COMMIT REJECTED DNC violation): see below for details"
	Write-Host $violations
	exit 1
}

# If there are no violations, exit without an error code.
exit 0
```

```takeaways
- You can add your own `pre-commit` scripts which go over your changes and check for DNC violations
- On UNIX systems, you'll need to `chmod +x`
- The scripts can be BASH, PowerShell (which requires a `.ps1` extension on Windows), Python or what have you.
  On UNIX systems, specify your interpreter with a shebang (`#!`)
- I've supplied a BASH script and a PowerShell script - you can see both above or on this [GitHub Gist](https://gist.github.com/guywaldman/235530baff33fb3409c19e5e81b5a206)
```

## Conclusion

So, my friends, we have seen how we can leverage git hooks to spare our code reviewers, and add a simple
automation by leveraging a nice (and not that well-known, surprisingly) feature in our daily VCS tool.

See you at the next one!

> P.S. Recently added an [RSS feed](/rss/feed.xml) to this blog, if it's useful to anyone.

```credits
Thanks to the awesome [Michael Kuritzky Bakman](https://www.linkedin.com/in/kuritzkym/) for reviewing this blog post!
```



Today, GitHub announced [GitHub Copilot](https://copilot.github.com/) which is essentially AI-powered code auto-completion; intellisense on steroids, if you will.  
What Copilot is, as the name suggests, is the **ultimate pair-programmer** you always wished for; for example, you start typing a function signature and it auto-completes
the rest of the function.

![From https://copilot.github.com](/future-of-software-development/copilot.png)

I was actually privileged enough to be included in the beta, but due to lack of free time these past few weeks I did not try it out. Boy, was I missing out!  

So what's under the hood? Well, _GitHub Copilot_ is powered by **GPT-3**, a sophisticated artificial intelligence model by OpenAI.
And what is GPT-3? Well, it is an autoregressive language model that utilizes deep learning. In layman terms - **it is able to predict text, and is trained using a neural network**. 
You can "program" the model using examples (think: Q&A) after which, given a new and perhaps unfamiliar input, it will generate a predicted answer according to the trained dataset. 
For example, you could train GPT-3 with examples containing made-up arithmetic expression with emojis as operators and their answers, and given a new such expression it will do its best to generate
an answer based on the examples you gave it.  
Microsoft has gained exclusive rights to GPT-3 (meaning, even if others may have access to the API - only it can modify it) and has leveraged this to train GPT-3 on, I assume,
as much source code as the internet could supply.

People have used GPT-3 for a lot of creative applications, a particular one which jumps to mind is someone training the model to generate a web application based on received instructions
in human language - see [this tweet](https://twitter.com/sharifshameem/status/1284095222939451393?s=20).  
GPT-3 is amazing (and even occasionally scary) at picking up on patterns you couldn't see with the naked eye.

However, as with anything, there are downsides. Notably:

1. This field is still young and emerging, and some of the predictions are not quite there yet
1. The predictions don't necessarily optimize for readability, performance, maintainability or security - humans are better at this, and probably will be for the foreseeable future
1. The predictions don't necessarily consider the context in which they are written (e.g. other included files in the project)

Therefore, if using these tools **please carefully audit the code that is generated**.
As mentioned, even if the solution works, it is still trained on source code (and I assume mostly open source), so if you're not careful,
you may well end up with unmaintainable code, subtle bugs, security vulnerabilities, etc.

Note that while _Copilot_ is the new kid in the block, it is not the only such product.
One notable contender is **[TabNine](https://www.tabnine.com/)** (and also Codota, which TabNine acquired in 2020 and are now a single product).
I have personally used TabNine and can attest that it felt like magic at times, as does Copilot now. 
With time, I am certain these products will only improve and introduce new innovations. 
There is also [Kite](https://www.kite.com/).
Another honorable mention, though aimed at symbol completion rather than completion of entire snippets of code, is **[Intellicode](https://marketplace.visualstudio.com/items?itemName=VisualStudioExptTeam.vscodeintellicode)**.
This is also a tool I used, and it does come in handy at times.

> By the way, Hebrew speakers - Eran Yahav, the CTO of TabNine (among other things), was a guest on a popular Israeli podcast around software development a while back - they discussed
> the integration of AI in our development workflows and it is very relevant to this blog post. 
> Check it out [here](https://open.spotify.com/episode/7Hc0MVQ0PlyWdcUmPJdepk?si=oCisX3VXTLqNtJYiyGEzRg&dl_branch=1), highly recommended.
> 

Now, to all of you reading this right now scared for their jobs - **don't be**! If anything, I believe this will only make our lives _easier_. 
I believe the days of replacing humans with fully automated software craftsmanship is still a distant fantasy (if at all) - but, AI-assisted programming and having a digital pair-programmer guiding you
towards the desired output is what I believe to be the future. 
Perhaps for delicate and maybe even convoluted logic, it may struggle; however, for mundane tasks this could be a serious productivity boost.

![Don't be this guy. We're good... for now.](/future-of-software-development/dey-took-our-jerbs.jpeg)

## Alright, Now What?

So I think we've established AI-assisted auto-complete is cool beans. Now what?  
Well, I think these developer toolings have a lot of potential. As mentioned, especially **mundane and repeating tasks could often be made redundant**. Seriously, try these tools - you'll see what I mean.  
Now, as this is an emerging field, as we gain advancements in research and domain knowledge, these applications will only get better. 
As one of my favorite YouTube channels [Two Minute Papers](https://www.youtube.com/c/K%C3%A1rolyZsolnai) likes to put - just imagine what will happen two papers down the line!
So as mentioned, I'm not only wary but actually very excited for what development platforms will allow in the next couple of years, and I have a vision.

...

Oh, what's the vision, you ask? Right, sorry.  

So, what I envision are that no-code/low-code tools (e.g., Wix, Wordpress, Webflow, Bubble) will — in line with their value propositions — not require much code. Astounding, I know!  
However, unlike now, when they do I think they could **rely on automatically generated code** by a sophisticated AI-powered language model (GPT-42 perhaps).   

Now, I don't think they will be perfect, even a decade or two down the line; they will probably require tweaking, the alternative might simply be too risky or infeasible.
In my opinion, this "tweaking" could be similar to a code review process.

So, consider this flow:

  1. You **describe the requirements** in natural human language
  1. You **provide tests** for verifying the logic - either describe them (which admittedly might make this kind of a circular problem), or write them out specifically
  1. The model **generates an iteration of code**
  1. **"Code review"** - you comment on the parts where the logic is incorrect, doesn't make sense, doesn't compile etc.
     These comments will describe why the logic is incorrect, what it should be changed to, and perhaps optionally provide a predicate to verify that the logic is correct
  1. Optionally, **manually code** sections where you think the AI needs more hand-holding
  1. The model **applies the comments** from the code review and presents another iteration
  1. You **either accept the changes or reject them**; for the latter, you would go back to step #3
  1. The requirements, code output, code review changes and the changes that resolve them - are all **"fed back" into the system** as potential training data
     to enhance the algorithm and model (which would make valuable insights)

I think there is merit to this - we **reverse the equation** and instead of having the AI assist us, we assist the AI.
We're the reviewers and also the QA, guiding and verifying along the way.
Trade this off with authoring the code end-to-end; what I basically claim here is that this pays off when the model is sophisticated enough. And when it isn't? Well, that's what escape hatches are for - opt out and code it yourself. 
I will agree for some cases, that sure, this might be overkill. But as a high-fidelity integrated automated authoring tool, I believe the ROI is high enough.

So, my friends, perhaps my elevator pitch to you (and a long elevator ride, at that) did not convince you. That's okay! It's not feasible now anyway.  
However, just you wait. In a few years? Well, it might just be crazy enough to work.



## Basic goal

In a project I'm working on, I had a simple problem that required taking some HTML (generated by React, but that doesn't really matter),
and generating a PDF from it.

This, apparently, was not as straightforward as I would have liked, as confirmed by Daniel's tweet here:

```tweet
https://twitter.com/autiomaa/status/1364906400778977284
```

So, for the sake of Daniel and other interested parties, I decided to write something about my experience, in the hopes it would benefit someone.

## What is a PDF anyway?

The _Portable Document Format_ needs no introduction - it's a ubiquitous format used to display documents independent of the software, hardware, or operating system.  
Our end goal would be to take a web page and generate a PDF from it.

An important property of the PDF is actually hinted by its name - _portable_; a PDF needs to be displayed consistently across platforms (and across PDF readers like Adobe Acrobat or Foxit).  
What this means is that a PDF needs to contain all the information needed to display inside the actual file. This includes things like fonts, images, vector graphics etc.  
Consider if Bob creates a cool document with a cool font like [Inter](https://fonts.google.com/specimen/Inter?preview.text_type=custom) and wants to send it to Alice.
Bob creates a Word document if he's on Windows or a Pages document if he's on a Mac, right? Well, when Alice opens the document, she can't see the font that Bob used!
She may even get a warning that the font used in the document is not installed on her system.
To accurately represent the content that Bob wants to send, he would need to use a file format which encapsulates all the information needed to display it; that is what the PDF is used for.

To be precise:

> PDF combines three technologies:
>
> - A subset of the PostScript page description programming language, for generating the layout and graphics.
> - A font-embedding/replacement system to allow fonts to travel with the documents.
> - A structured storage system to bundle these elements and any associated content into a single file, with data compression where appropriate.
>
> (from [https://en.wikipedia.org/wiki/PDF](https://en.wikipedia.org/wiki/PDF))

PDF is magic! Or at least, as Arthur Clarke puts it, _"Any sufficiently advanced technology is indistinguishable from magic."_  
It is also [a very inconsistent format](https://www.reddit.com/r/software/comments/3f1b5r/why_is_pdf_such_an_inconsistent_format/ctkgc7q?utm_source=share&utm_medium=web2x&context=3) but let's not get into that here.

Hey, there's a reason why it's the most popular religion:

![](/web-page-to-pdf/pdf-religion.png)

## Requirements

Let's quickly establish the basic premise of this blog post - I want to **take some arbitrary HTML and generate a high quality PDF** that answers to the following requirements:

```info
Note that the PDF you want to generate may not have all these requirements (for example, you may be content with a single "screenshot" of the DOM element as an image inside the PDF),
so consider whether these are important for you too.
Later we'll go over some common approaches which do not guarantee these requirements, but may be fine for what you are trying to achieve!
```

1. **Consistency** - The DOM element (for the uninitiated, the [DOM](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) is essentially the in-memory representation of a web page) may not look the same across browsers, or even operating systems.  
   If you want your PDF to look the same no matter how your users access your website, this may be of high significance.
1. **Fidelity** - The PDF should retain as much of the quality of the content in the DOM element, so the text or SVGs will retain the vector information, images will preserve their original quality, etc.  
   This also means that the CSS applied on the web page will need to look the same in the generated PDF.
   When I present the different approaches, you'll see why this is not trivial.
1. **Generic** - The approach should be able to be applied to any arbitrary HTML, so we would need to need to set anything up ahead of time.
   We would want no special handling for embedding certain types of content (a-la images, SVGs) or special handling for different types of HTML tags.
   Everything should Just Work™.  
   This is especially important since, in my project, I need to be able to quickly set up a PDF conversion on changing content.

```takeaways
We want to consistently generate a PDF from a web page that should:
1. Be high-fidelity and preserve all information required to render the web page (CSS, fonts, images, SVGs)
1. Be generated on the fly for any arbitrary HTML
1. Look the same on whichever platform the users are running from
```

## First approaches

So, let's begin by looking around the interwebs for some popular JS-to-PDF converters.  
Mhm, seems like [jspdf](https://github.com/MrRio/jsPDF) or [pdfkit](https://github.com/foliojs/pdfkit) are pretty popular.

Alas, it seems like `jspdf`'s main usage is building a PDF programmatically.

e.g.

```js 4
import { jsPDF } from "jspdf";

const doc = new jsPDF();
doc.text("Hello world!", 10, 10);
doc.save("a4.pdf");
```

With this library, seems like we need to _manually_ specify the elements we require and build the PDF ahead of time.
This does not scale well and does not fulfill our "Ergonomics" requirement since we want to generate a PDF dynamically based on a dynamic web page.

Looking at [pdfkit](https://github.com/foliojs/pdfkit), which is another great library I considered, it seems to have the same drawback.

Mhm, no luck so far. But I was never one to back down easily!

So, coming back to `jspdf` - it also has a `.html` method which, at first glance, appeared to be what we want:

```js 3
const doc = new jsPDF();
const source = document.getElementById("convert-me-to-pdf");
doc.html(source, {
   callback: (doc) => {
      // This callback is invoked after the DOM is converted to a PDF.
      // We can now save the generated PDF.
      doc.save();
});
```

Here is a small proof of concept for doing this: [https://codesandbox.io/s/convert-to-pdf-jspdf-p9cnk](https://codesandbox.io/s/convert-to-pdf-jspdf-p9cnk)

> I used a `<div>` with an `<svg>`, an `<image>`, a heading and some text, with various styles (made easy with TailwindCSS).
> Try playing around with it and changing the content inside.

I tried a few libraries similar to that, but soon realized that this wasn't the direction I needed to go in.
You would notice, if you tinkered around with it, that layout was often not preserved, images/SVGs were often not correctly rendered (if at all), etc.

This did not fulfill the "Consistency" requirement (not to mention that the PDF could still look differently across different browsers and operating systems).
Another important note for using `jspdf` or similar libraries - all the CSS you use needs to be included in the DOM you render.
That means one of these two options (or a combination of both):

- Inlining the CSS with `style` attributes
- Including all the CSS stylesheets you use. Note that this means actually including the CSS itself in `<style>` tags, you can't link to external CSS stylesheets from a CDN!  
  In my case, of using [TailwindCSS](https://tailwindcss.com/) this meant downloading the stylesheet from their CDN and plopping it into `<style>` tags (alternatively I could build my CSS and include that)

Keeping optimistic, I stumbled across [react-to-pdf](https://www.npmjs.com/package/react-to-pdf) (I used React for this project).
This seemed promising at first glance, however it also seems to be using `jspdf` under the hood
and similarly to other such libraries that I found, note the final bullet in the important notes section of `react-to-pdf`:

> Not vectorized - the pdf is created from a screenshot of the component and therefore is not vectorized.
> If you are looking for something more advanced for generating pdf using React components, please check out other popular alternatives packages listed below.

What this means is that the generated PDF is a plain image converted to PDF. The last suggestion on checking the alternative packages seems to be PDF renderers.
I saw several solutions like these (which, if I recall correctly, often take advantage of HTML `<canvas>`) but they do not fulfill the "Fidelity" requirement.

But wait... though doing this on the client-side seemed great at first, maybe that is not the correct way to go about it.

Generating the PDF on the client-side would mean:

1. It would generate the PDF based on the user's platform and browser. So someone using Chrome on macOS may not see the same PDF as someone using Firefox on Windows.  
   This does not fulfill the "Consistency" requirement
2. It would run on the user's machine, so if we were to have a very rich DOM, a low-end device (especially mobile) could struggle with this, or take a long time

```takeaways
The solutions I found to generate a PDF on the client-side are usually one (or several) of the following:
1. Meant for programmatically generating a PDF (not what I needed, does not fulfill the "Generic" requirement)
2. Do not generate a high-fidelity PDF (with the CSS, fonts, vector information), thus not fulfilling the "Fidelity" requirement
3. Inconsistent or buggy, especially with rich content

Even if I were to find such a library - it would still be insufficient, due to the fact it runs on the user's machine, and thus may look different on different platforms,
or may be computationally intensive on low-end devices.
```

## Server-side - the best side?

So, as I established in the end of the previous section, generating the PDF on the user's machine has some drawbacks.

I then thought - in the browser, when we "print to PDF", we always get a very high quality PDF, right?
It looks the same as the web page (you can target `print` specifically with CSS `@media` queries with [great browser support](https://caniuse.com/css-mediaqueries)), preserves the font, images and vector graphics.
So, simulating something like this on the server-side seemed like it might be a good approach.
Upon some further research, I decided that this was not an original idea (which is always a good sign in our line of work, to be honest), and it might just be crazy enough to work.

So, how do we simulate a "print to PDF"?
Well, it essentially boils down to the question of simulating a browser, and this I know! Let's use headless browsers.
For those who are unfamiliar, what headless browsers are running browser instances, except without the UI.
This type of browser automation comes up a lot when testing, but is also useful for other things like scraping or in our case, generating PDFs!

I have experience with [puppeteer](https://github.com/puppeteer/puppeteer) so that is what I chose to use.  
There are other very nice alternatives such as [playwright](https://github.com/microsoft/playwright), which would also do very nicely here
(Playwright also has the added benefit of supporting other browsers such as Firefox, but we don't actually need that here).

Puppeteer simulates Google Chrome, and we get some nice benefits:

1. By always using the same browser and running this PDF generator on the same platform (e.g. Ubuntu) means we get consistent looking UI between renders
1. Puppeteer uses a recent version of Chrome which provides the ability to use the latest and greatest of web technologies
1. Puppeteer also has a "non-headless" mode, which does the same thing but displays the actual UI when it's running. This is useful for testing it out when things go wrong

Okay, so let's draw up a game plan:

1. Spin up a headless browser in Puppeteer
1. Generate an HTML [data URI](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs) for our web page (with all its dependencies, such as fonts or stylesheets)
1. Print the page to an A4 PDF

Indeed, this turned out great in practice.
I used [Vercel serverless functions](https://vercel.com/docs/serverless-functions/introduction) in my [Next.js](https://nextjs.org/) application.

However, note that if you simply tried this, it wouldn't immediately work - Puppeteer needs to use a Chromium (the engine behind Google Chrome) binary and the server probably does not have it installed.
Vercel functions, which I used for this, run on AWS Lambdas under the hood, so fortunately there is a handy NPM package for this called [chrome-aws-lambda](https://github.com/alixaxel/chrome-aws-lambda) which ships with
the correct Chromium binary for Puppeteer to use.

Some sample code for a Next.js API endpoint could look like this (using Typescript):

```ts
import type { NextApiRequest, NextApiResponse } from "next";
import puppeteer from "puppeteer";
import chrome from "chrome-aws-lambda";
import React from "react";
import ReactDOMServer from "react-dom/server";
import ComponentToRenderToPdf from "..."; // Example

async function printPDF(name: string) {
  const browser = await puppeteer.launch(
    process.env.NODE_ENV === "production"
      ? {
          args: chrome.args,
          executablePath: await chrome.executablePath,
          headless: chrome.headless,
        }
      : { headless: true }
  );
  const page = await browser.newPage();

  // Render the desired React component to a string.
  const html = ReactDOMServer.renderToString(
    <html>
      <head>
         { /* Optionally include external stylesheets here. */ }
      </head>
      <body>
         <ComponentToRenderToPdf name={name}>
      </body>
    </html>
  );

  // Navigate to an HTML data URI with the HTML we generated before.
  const response = await page.goto("data:text/html," + html, { waitUntil: ["networkidle0"] });
  if (!response.ok()) {
     // Handle error appropriately.
  }

  await page.emulateMediaType("print");
  const pdf = await page.pdf({ format: "a4", printBackground: true });

  // Clean up after ourselves like good citizens.
  await browser.close();

  return pdf;
}

export default async (req: NextApiRequest, res: NextApiResponse<Buffer>) => {
  // Optionally use the request and pass parameters to render the component dynamically.
  const name = req.query.name;
  const pdfBuffer = await printPDF(name);

  // Return the result with a MIME type of `application/pdf`.
  res.setHeader("Content-Type", "application/pdf");
  res.setHeader("Content-Length", pdfBuffer.length);
  res.status(200).send(pdfBuffer);
};
```

And this works like a charm.
Navigating to my website with the relative URL `/api/renderPdf?name=Guy` renders the desired PDF, and the performance is great for my needs.

Another benefit of this approach is that the PDF also preserves the functionality of links 🥳

Note that there is still a drawback to this method - if you want to generate a preview of the PDF you want to render using the same React component,
if you're running it on a platform that is different than the server's, the PDF may look differently.
However, that is a trade-off that for my particular project I was willing to live with.

```takeaways
We built a serverless function that, on-demand:
1. Spins up a Google Chrome headless browser instance (by leveraging Puppeteer)
1. Opens an HTML data URI that we created from our HTML (or React component in this case)
1. Prints the web page to a PDF that fulfills all our original requirements
```

## Conclusion

So, my friends, in our journey to becoming a PDF-generation masters, we realized that generating PDFs on the client-side is not straightforward and is also
not the ideal solution to fulfill our requirements and so we went with a server-side approach with a headless browser.

This was not a challenge that I needed to solve in the best possible way and I settled on a "good enough" solution for my use-case.  
Therefore, if you feel that I missed something or if there are better approaches out there, please do not hesitate to reach out!



What does any blog author with two posts need? _"More content!"_ I hear you shout, to which I say - not today!
I have decided to add - _drum roll, please_ - some anchor links to the headings!
Okay, I lied, I did indeed decide to make some content around it, since the last time I posted a blog post... Well, let's just say it's been a long time to avoid embarrassment.

So what are anchor links, anyway? If you're unfamiliar, anchor links are basically links to specific sections of a page.  
Try hovering over one of the headings in this page, and clicking on the icon next to it - it will append a `#` with the heading
(e.g. `#adding-the-anchor`) and will scroll the page so that it focuses on the heading. If you navigate to this URL, it will also focus on the heading.  
How this works is not magic - the ID of the heading should match the heading "slug"; In this example, the "Adding the Anchor" `<h2>` heading has an ID of `adding-the-anchor`.
Try inspecting the HTML and seeing for yourself!

> Note: If you link to a page's heading (for example, in technical documentation), bear in mind that the heading can change
> (which may "break" your link and lead folks to the top of the page rather than a specific section) but web developers
> are aware of this functionality and may not change the ID to avoid that.  
> [Text Fragments](https://web.dev/text-fragments/) are also useful for this kind of stuff (but are much more prone to breaking).
> 

So, let's begin with the simplest heading and see how you would go about doing something like this:

```html
<h2>Adding the Anchor</h2>
```

> The actual code I use to render headings is omitted for simplicity (and accounts for various level of heading tags).

Let's break this down into three parts:

1. Add the anchor to the heading
2. Display it only on hover
3. Add the actual anchor link functionality

## Adding the Anchor

First, let's style the heading a bit (I will not be assuming any predefined styles):

```css
h2 {
  font-weight: bold;
  font-size: 40px;
  font-weight: bold;
}
```

This should look something like this:

![](/anchor-links/01.png)

Let's wrap the heading in a `<div>` with a class of `container` (we'll style that soon) and add a link icon from [heroicons](https://heroicons.com/) with a class of `icon` (also to be styled later):

```html 2-5
<div class="container">
    <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
         stroke="currentColor" class="icon">
      <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1" />
    </svg>
  <h2>Adding the Anchor</h2>
</div>
```

Now, let's style the icon a bit:

```css
.icon {
  color: #9ca3af;
  width: 18px;
  height: 18px;
}
```

> Note: By setting the SVG's `stroke` property to `currentColor` (that is also how it's copied from Heroicons), we can change the text color and it will control the SVG's stroke.
> This technique is particularly useful in CSS utility libraries like Tailwind, in which you have special classes for the setting the text color.

At this point we should have something like this:

![](/anchor-links/02.png)

Instead, what we want to do is have them on the same line - we'll use Flexbox for that.  
We'll also want to align them both to the bottom, so an `items-end` class should take care of that:

```css 1-4
.container {
	display: flex;
	align-items: flex-end;
}

.icon {
	color: #9CA3AF;
	width: 18px;
	height: 18px;
}

h2 {
	font-weight: bold;
	font-size: 40px;
	font-weight: bold;
}
```

Another important thing we'll want to do, in my case, is have the heading stay put, and move the anchor link to the left of it.
The way to achieve is adding a wrapper with a `position: relative`, and adding a wrapper over the SVG with a `position: absolute`, thus detaching it from the document flow.  
We'll also move it up a bit, so that its bottom end aligns with the text's baseline (there are better ways to achieve this, but this will be do for our purposes).

```css 2,8-10
.container {
	position: relative;
	display: flex;
	align-items: flex-end;
}

.icon {
	position: absolute;
	left: -36px;
	bottom: 4px;
	color: #9CA3AF;
	width: 18px;
	height: 18px;
}

h2 {
	font-weight: bold;
	font-size: 40px;
	font-weight: bold;
}
```

![](/anchor-links/03.png)

## Displaying on Hover

Alright, let's say that we're content with this. Now how do we only show it on hover?

Doing this in JavaScript would be very simple; however, I always tend to try and make things work using only HTML and CSS, before asking JS for help.

So, let's set the icon to `display: none` and when the container is hovered, let's change it to `display: block`.  
No sweat, right?

```css 7-9,12
.container {
	position: relative;
	display: flex;
	align-items: flex-end;
}

.container:hover .icon {
  display: block;
}

.icon {
	display: none;
	position: absolute;
	left: -36px;
	vertical-align: text-bottom;
	bottom: 4px;
	color: #9CA3AF;
	width: 18px;
	height: 18px;
}

h2 {
	font-weight: bold;
	font-size: 40px;
	font-weight: bold;
}
```

Now we get to the tricky part, however.
Do you notice the issue? When we hover over the title, and then move our mouse to the anchor - it disappears!

How I solved this (and I am sure that there are other, possibly better approaches out there) is by essentially expanding the "hit box" of the heading
with a neat hack - I added `padding-left: 36px` (which gave the text left padding, thus moving it to the right) and "corrected" it by moving it back left with a `left: 36px` (the class is already `position: relative` so no need to set it).
This alone would work, except it would also move the icon left by `36px`, so I set the icon to `left: 0`.

```css 5-6,16
.container {
	position: relative;
	display: flex;
	align-items: flex-end;
	padding-left: 36px;
	right: 36px;
}

.container:hover .icon {
  display: block;
}

.icon {
	display: none;
	position: absolute;
	left: 0;
	vertical-align: text-bottom;
	bottom: 4px;
	color: #9CA3AF;
	width: 18px;
	height: 18px;
}

h2 {
	font-weight: bold;
	font-size: 40px;
	font-weight: bold;
}
```

## Adding the Functionality

To make this into a working anchor link, we need to make sure of two things:

1. Add an ID to the heading (its "slug", e.g. for "Adding the Anchor" we could use `adding-the-anchor`)
2. Make the anchor icon a link to the same page, with an added `#adding-the-anchor`

The HTML would look something like this:

```html 2,7-8
<div class="container">
	<a href="#adding-the-anchor">
		<svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24"
			stroke="currentColor" class="icon">
		<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13.828 10.172a4 4 0 00-5.656 0l-4 4a4 4 0 105.656 5.656l1.102-1.101m-.758-4.899a4 4 0 005.656 0l4-4a4 4 0 00-5.656-5.656l-1.1 1.1" />
		</svg>
	</a>
  <h2 id="adding-the-anchor">Adding the Anchor</h2>
</div>
```

This concludes this post! I hope it proved useful to at least some of you.

If it helps, here is a Codesandbox which demonstrates this in action: [https://codesandbox.io/s/anchor-link-demo-nk9ez](https://codesandbox.io/s/anchor-link-demo-nk9ez)



3 years ago I created [this UI experiment](https://codepen.io/guywald/pen/xOPqyo) on CodePen, for a call to action with a ripple effect
like ones based on [material design](https://material.io/components/buttons/).
For this post, I'll share how to achieve a similar effect.

This is the final result: [https://codesandbox.io/s/material-button-vanilla-xf9pi]()

In order to achieve this effect, we will rely on CSS animations for the actual ripple but will have to use JavaScript
to obtain the relative mouse position after the button is clicked.
These relative coordinates will be used by the CSS through CSS variables.

I will demonstrate this component in vanilla JavaScript, but stay tuned until the end
if you are interested in this component **in React**.

## Getting Started

Let's start off with the simplest of buttons:

```html
<button class="btn">Click Anywhere</button>
```

We will give the button some basic CSS for resetting its appearance across browsers, center the text and give it some life.
We will use a fixed width and height and center the text horizontically and vertically using Flexbox.

I would normally not hard-code the width and just give it some padding, to conform to dynamic text, but the reason will be explained later on.
Just trust me for now. 😇

```css
.btn {
  /* Reset styles */
  appearance: none;
  outline: none;
  background: none;
  border: none;

  width: 12em;
  height: 3em;

  /* Center text */
  display: flex;
  justify-content: center;
  align-items: center;

  padding: 0.5em 1em;
  font-size: 20px;
  border-radius: 0.3em;
  background: #42a5f5;
  color: #e3f2fd;
}
```

Let's add some shadow for a more material design-y look.
I usually go for a big soft shadow, stacked with a tighter more profound shadow. We will add a `transition` for a nice animation.

> Note that animating `box-shadow` is _not_ GPU-accelerated (like `opacity` and `transform`) so it may cause some UI jank. Use with caution!

```css
.btn {
  /* Reset styles */
  appearance: none;
  outline: none;
  background: none;
  border: none;

  width: 12em;
  height: 3em;

  /* Center text */
  display: flex;
  justify-content: center;
  align-items: center;

  padding: 0.5em 1em;
  font-size: 20px;
  border-radius: 0.3em;
  background: #42a5f5;
  color: #e3f2fd;

  transition: box-shadow 250ms ease;
}

.btn:hover {
  box-shadow: 2px 5px 5px 0px rgba(2, 119, 11, 0.2), /* soft shadow */
  1px 2px 3px 0 rgba(2, 119, 11, 0.1); /* harsh shadow */
}
```

## Adding the Ripple

We will a `div` for our ripple, which we will place before the text.
Our ripple will essentially be a circle which should expand after clicking anywhere on the button, fading in and out.

We will also surround the text with a `div` and give them appropriate `z-index` values, so that the ripple does not obscure the text.

```html
<button class="btn">
  <div class="btn__ripple"></div>
  <div class="btn__text">Click Anywhere</div>
</button>
```

We will want to supply our ripple with coordinates to be placed relatively to the button.
We will mock this for now in the CSS and add this functionality later.

First, we will add a `position: relative` to the button so we can add a `position: absolute`
to the ripple and position it relatively to the button (a `position: absolute` element will
be positioned relative to its first ancestor that is `relative`-ly positioned).

We will use **CSS variables** to mock our mouse coordinates when the button is pressed.
If you have not yet heard of CSS variables (or "custom properties"), [you should](https://developer.mozilla.org/en-US/docs/Web/CSS/Using_CSS_custom_properties)!
They are very useful for many things, adhere to the cascade, and the [browser support](https://caniuse.com/#feat=css-variables) is pretty good!

The CSS variables will be added to the button element and not the ripple, since they will be cascaded to all of its inner
elements (the ripple being one of them), but as a general habit I tend to scope the variables to the component, in case they will be needed
in other children of the element. You don't have to do this if you think otherwise.

We will also add an `overflow: hidden` to the button to obscure the ripple that goes out
of its frame.

We will give the ripple the same amount for width and height with a `border-radius` of `50%` to make it a nice circle.
This is why it was important that we set hard-coded width and height to the button before -- going for relative dimensions here could make for a "stretched" oval which
wouldn't look as nice.
For not getting ripples too small for the containing button, I went for hard-coded values in both.

Finally, we will set the `left` and `top` properties according to the CSS variables on the button, which we mocked.
For the `left` property we will substract half of the ripple's width, to center it.
We will do the same for the `top` property, but with the circle's height.

```css
.btn {
  /* Mock the CSS variables (temporary) */
  --left: 12px;
  --top: 24px;

  /* Reset styles */
  appearance: none;
  outline: none;
  background: none;
  border: none;

  position: relative;
  width: 12em;
  height: 3em;

  /* Center text */
  display: flex;
  justify-content: center;
  align-items: center;

  padding: 0.5em 1em;
  font-size: 20px;
  border-radius: 0.3em;
  background: #42a5f5;
  color: #e3f2fd;

  transition: box-shadow 250ms ease;

  overflow: hidden;
}

.btn:hover {
  box-shadow: 2px 5px 5px 0px rgba(2, 119, 11, 0.2), /* soft shadow */ 1px 2px
      3px 0 rgba(2, 119, 11, 0.1); /* harsh shadow */
}

.btn__ripple {
  position: absolute;

  /* We offset half of the circle's radius to center it */
  left: calc(var(--left) - 2em);
  top: calc(var(--top) - 2em);

  width: 4em;
  height: 4em;

  background: #64b5f6;
  border-radius: 50%;

  z-index: 0;
}

.btn__text {
  z-index: 1;
}
```

## Adding Functionality

Now we will receive the coordinates of the mouse when clicking the button, and propagate them to the
CSS variables.

We will add some IDs for the button and the ripple:

```html
<button id="btn" class="btn">
  <div id="ripple" class="btn__ripple"></div>
  <div class="btn__text">Click Anywhere</div>
</button>
```

And an event listener for mouse clicks:

```js
const $button = document.getElementById("btn");
const $ripple = document.getElementById("ripple");

$button.addEventListener("click", e => {
  // Let's handle the click!
});
```

Now, to calculate the relative position of the mouse from the top left corner of the button,
we will use the `pageX` and `pageY` properties on the mouse event from the callback, which will give us
the absolute coordinates of the mouse relative to the viewport.
For the relative _left_ position from the _button_, we will substract the button's DOM element's offset from the left side
of the viewport - its `offsetLeft`. Same goes for the top relative position - we will subtract the button's `offsetTop`.

```js
const $button = document.getElementById("btn");
const $ripple = document.getElementById("ripple");

$button.addEventListener("click", e => {
  const left = e.pageX - $button.offsetLeft;
  const top = e.pageY - $button.offsetTop;

  // Now what?
});
```

After we have these values, what's left is passing these to our button.
How would we do that?
Well, with the CSS variables we mocked earlier! Now we'll pass them the actual values.

```js
const $button = document.getElementById("btn");
const $ripple = document.getElementById("ripple");

$button.addEventListener("click", e => {
  const left = e.pageX - $button.offsetLeft;
  const top = e.pageY - $button.offsetTop;

  $button.style.setProperty("--left", left + "px");
  $button.style.setProperty("--top", top + "px");
});
```

Great! Now let's remove the mock.

## Adding Animations ✨

To get a growing ripple, we will want to have 2 layered animations:

1. A scaling animation, with the ripple going from a scale of `0` to a scale of `1`.
2. A fade animation, with the ripple going from an opacity of `0`, to an opacity of `1` (or some other value) and back to `0`.

For the animation, we will use a good ol' CSS animation.
But there's a problem -- we will need to somehow reset this animation every time the button is clicked.

So to actually trigger the animation, we will use a trick I learned back in the day from [this fantastic CSS-Tricks article](https://css-tricks.com/restart-css-animation/)
-- we have a class that sets off the animation and when we click the button - we will remove the class, trigger a reflow and add the class back.

The magic line that triggers the reflow basically computes a layout property on the DOM node, which therefore gives us
a "window" of sorts, in which we can remove and then add back the class responsible for the animation.

It should look something like this:

```js
const $button = document.getElementById("btn");
const $ripple = document.getElementById("ripple");

$button.addEventListener("click", e => {
  const left = e.pageX - $button.offsetLeft;
  const top = e.pageY - $button.offsetTop;

  $button.style.setProperty("--left", left + "px");
  $button.style.setProperty("--top", top + "px");

  $ripple.classList.remove("ripple");
  void $ripple.offsetWidth; // Force layout refresh
  $ripple.classList.add("ripple");
});
```

Now, let's add the actual animations:

```css
.btn {
  /* ... */
}

.btn:hover {
  /* ... */
}

.btn__ripple {
  /* ... */
}

.btn__text {
  /* ... */
}

.btn__ripple.ripple {
  animation: ripple-opacity-anim 500ms ease, ripple-scale-anim 500ms ease;
}

@keyframes ripple-opacity-anim {
  0% {
    opacity: 0;
  }
  70% {
    opacity: 0.5;
  }
  100% {
    opacity: 0;
  }
}

@keyframes ripple-scale-anim {
  from {
    transform: scale(0.5);
  }
  to {
    transform: scale(1);
  }
}
```

The `70%` I chose for the peak time of the opacity for the ripple, and `0.5` for the peak value are
personal taste and I encourage you to experiment and see what you like best!

All that's left is scaling up the ripple; When doing this, don't forget changing the offsets for `left` and `top` as well!
Also note that the larger the ripple will be, the faster the animation will look as well, so to compensate you can make the animation
play for a bit longer.

## React Component

For the React component, the styles would be the same, and the component would look something like this:

```jsx
function MaterialButton({ children }) {
  const buttonRef = React.useRef();
  const [isAnimating, setIsAnimating] = React.useState(false);

  function handleClick(e) {
    e.persist();

    const $button = buttonRef.current;

    if (!$button) {
      setIsAnimating(false);
      return;
    }

    const left = e.pageX - $button.offsetLeft;
    const top = e.pageY - $button.offsetTop;

    $button.style.setProperty("--left", `${left}px`);
    $button.style.setProperty("--top", `${top}px`);

    setIsAnimating(false);
    setTimeout(() => setIsAnimating(true), 0);
  }

  return (
    <button ref={buttonRef} className="btn" onClick={handleClick}>
      <div className={"overlay" + (isAnimating ? " grow" : "")} />
      {children}
    </button>
  );
}
```

Here we use a `ref` for accessing the button's DOM node and we use state to track whether
there is a ripple happening.
The magic for resetting the fade is queuing a microtask (the `setTimeout` with `0` milliseconds an argument)
to disable the `isAnimating` flag, therefore not interrupting the animation but preparing the component for the
next ripple.

## Closing Notes and Code

There you have it! Your very own ripple 😊

Some things could have probably been done better but I hope that the concepts are clear and that you learned some new tricks.
Before taking something like this to production, I would make sure that it works consistently across browsers. I have also used CSS variables here,
which as far as I know cannot be polyfilled; Therefore, if you plan on using them, make sure that they conform to your browser support.

I hope that you enjoyed this, please reach out to me if anything seems unclear, or just
to show me your awesome ripply buttons!

The final code can be found on CodeSandbox: [vanilla](https://codesandbox.io/s/material-button-vanilla-xf9pi) or [React](https://codesandbox.io/s/materialbutton-b4101).


Hey there! 👋

I'm Guy Waldman, a software developer and graphic designer from Israel and this blog will be a safe-haven for all my future ramblings.

## A bit about myself

I'm currently working at Microsoft Azure in the Israeli R&D center, building cloud security solutions.
Before starting work as a full-time employee Microsoft, I actually interned there as well while pursuing a B.Sc. in computer science from the Technion (a university in Israel).

I have many passions and interests, which is both a blessing and a curse. I've been mostly developing and designing web and mobile applications.
In the past few years, I've also taken a keen interest in the Rust programming language (and systems programming as a whole) so you can expect some content about Rust in the future.

Before pursuing my degree, I also worked in an animation studio as a digital artist (graphic design and occasionally some After Effects work). That was, and still is, my side-passion.

The programming languages I'm most proficient in are JavaScript (with various flavors), Python, Rust, C# and C++.
You will probably see these the most in my blog posts.

## What I will post about

Mostly software, design, and UI/UX -- but, really, anything that comes to mind!


Hey, I'm
GuyWaldman

Latest blog posts

Hey, I'mGuyWaldman

Latest blog posts

Hey, I'm
GuyWaldman