Nate

Hacky Way to Customize Shadcn’s Tooltip Arrows

Sun, 15 Dec 2024 00:00:00 GMT

Introduction

Shadcn is a go-to library for copy-paste UI components in React projects. One commonly used component is the Tooltip, which is built on top of @radix-ui/react-tooltip .

The default tooltip looks like this:

Adding Tooltip Arrows

While the provided component works well out of the box, I found myself wanting to add more customization—like adding an arrow to the tooltip. For inspiration, I turned to the Tooltip component from tremor.so, which is also based on @radix-ui/react-tooltip.

Fortunately, adding an arrow is straightforward since @radix-ui/react-tooltip includes an Arrow component. You simply need to include it inside the Content component.

import * as TooltipPrimitives from '@radix-ui/react-tooltip'

export default () => (
  <TooltipPrimitives.Provider>
    <TooltipPrimitives.Root>
      <TooltipPrimitives.Trigger />
      <TooltipPrimitives.Portal>
        <TooltipPrimitives.Content>
          <TooltipPrimitives.Arrow /> // Add the Arrow component here
        </TooltipPrimitives.Content>
      </TooltipPrimitives.Portal>
    </TooltipPrimitives.Root>
  </TooltipPrimitives.Provider>
)

However, what if you want to add a border around the entire tooltip, including the arrow?

Adding a Tooltip Border

To achieve this, you’ll need to style the Arrow component. Let’s explore some approaches:

Naive Approach

Adding a border directly to the Arrow using Tailwind classes seems like a good starting point:

<TooltipPrimitives.Arrow
  className='border border-[var(--tooltip-border-color)] fill-[var(--tooltip-color)]'
  width={12}
  height={7}
  aria-hidden='true'
/>

However, this approach doesn’t work as expected. The border property applies to the rectangular boundary of the element, not the arrow shape itself.

Using the `stroke` Property

Since the Arrow is an SVG element, you can use the stroke property to define a border:

<TooltipPrimitives.Arrow
  className='border-none fill-[var(--tooltip-color)]'
  stroke='var(--tooltip-border-color)'
  stroke-width='2'
  width={12}
  height={7}
  aria-hidden='true'
/>

This works better, but the arrow’s top border is still visible. To fix this, let’s explore another method.

Exploring the Drop Shadow Option

Another method is using a drop-shadow to simulate the border:

<TooltipPrimitives.Arrow
  className='-my-px border-none fill-[var(--tooltip-color)] drop-shadow-[0_1px_0_red]'
  width={12}
  height={7}
  aria-hidden='true'
/>

This creates a visually seamless tooltip with an arrow and border, but it might not always be the most precise solution depending on your use case.

It’s worth mentioning that this solution is inspired by the Tooltip component from Origin UI, which provides various customizable tooltip variants that can save development time.

How about styling it even more, like using my own custom SVG?

Custom SVG Arrow

I often visit Vercel’s website, and their dropdown navigation bar caught my eye, particularly the arrow.

Curious about how it was designed, I opened the dev tools, inspected the elements, and found the SVG arrow. I then copied it and pasted it into Figma for a closer look.

I thought it could be an interesting design choice for a tooltip arrow.

Positioning

Positioning the SVG arrow depends on the tooltip’s placement—top, bottom, left, or right. The Content component exposes a data-side attribute, which you can use to adjust positioning dynamically:

[data-side='top'] svg {
  bottom: -9px;
  left: 50%;
  transform: translateX(-50%);
}

[data-side='bottom'] svg {
  top: -9px;
  left: 50%;
  transform: translateX(-50%) rotate(180deg);
}

[data-side='left'] svg {
  right: -20.25px;
  top: 50%;
  transform: translateY(-50%) rotate(-90deg);
}

[data-side='right'] svg {
  left: -20.25px;
  top: 50%;
  transform: translateY(-50%) rotate(90deg);
}

Next, we could replace the built-in tooltip Arrow component with our custom design. It should work perfectly, right?

Well, not quite yet. Take a look at this: the arrow is stuck in the center of the tooltip instead of being positioned near the trigger.

This undesired behavior happens because we only defined a static position for each side. Instead, we need to use a dynamic position to solve this issue.

Dynamic Position

Let’s start by using the built-in Arrow component again. If you inspect the Arrow component in the dev tools while simulating the tooltip position change, you’ll notice that the SVG element is wrapped in a span with a left CSS property.

This value dynamically changes based on the tooltip's position. We can capture this left CSS value and apply it to our custom arrow component.

To track this left value, we need to observe it using a MutationObserver.

// tooltip-arrow-primitive.tsx

import { Arrow } from '@radix-ui/react-tooltip'
import React from 'react'

const TooltipArrowPrimitive = () => {
  const arrowRef = React.useRef<SVGSVGElement>(null)

  React.useEffect(() => {
    const spanArrow = arrowRef.current?.parentElement

    const observer = new MutationObserver(() => {
      if (!spanArrow) return

      const style = window.getComputedStyle(spanArrow)

      // Get our custom tooltip component by its id
      const tooltipArrow = document.getElementById('tooltip-arrow')

      // Assign the left value as the style attribute
      tooltipArrow?.setAttribute('style', `left: ${style.left};`)
    })

    if (spanArrow) {
      observer.observe(spanArrow, {
        attributes: true, // Observe changes to attributes
        attributeFilter: ['style'] // Only look for changes to the style attribute
      })
    }

    return () => {
      observer.disconnect()
    }
  }, [])

  return <Arrow ref={arrowRef} id='primitive-arrow' className='opacity-0' />
}

export default TooltipArrowPrimitive

Then, we can call it inside the Content component.

import CustomTooltipArrow from './tooltip-arrow'
import TooltipArrowPrimitive from './tooltip-arrow-primitive'

export default ({ children, showArrow }) => (
  // Adjust each component props as needed
  <TooltipPrimitives.Provider>
    <TooltipPrimitives.Root>
      <TooltipPrimitives.Trigger />
      <TooltipPrimitives.Portal>
        <TooltipPrimitives.Content>
          {children}
          {showArrow && (
            <>
              <TooltipArrowPrimitive />
              <CustomTooltipArrow />
            </>
          )}
        </TooltipPrimitives.Content>
      </TooltipPrimitives.Portal>
    </TooltipPrimitives.Root>
  </TooltipPrimitives.Provider>
)

Final Result

It’s working as expected now 🥳🎉

P.S. You might want to adjust the top position if you prefer displaying the tooltip on the left or right side.

Conclusion

While this approach works, I’m sure there are UI libraries that allow for easier and more flexible tooltip styling. However, it feels rewarding to have found a workaround for this. If you're interested in exploring other options, you might want to check out this discussion.

Setting Dynamic Default Values with Zod Schema

Thu, 12 Dec 2024 00:00:00 GMT

Introduction

Zod provides a powerful way to define schemas for validating and transforming data. You can easily define default values for properties.

but what if you need a default value based on another property in the schema?

Let’s explore how to handle that using Zod.

Simple Default Value

First, let’s see how we can define a simple default value for a property using Zod:

const schema = z.object({
  name: z.string().default('John Doe')
})

In this example, the name property will have a default value of 'John Doe' if not supplied during parsing.

What If the Default Depends on Another Property?

Now, let’s consider a more complex case where the default value of one property depends on another. For instance, imagine we have a blog schema where the displayedTitle is the same as the title, but with a line break included for formatting purposes.

Here’s the basic schema:

const blogSchema = z.object({
  title: z.string(),
  displayedTitle: z.string()
})

Next, let’s define a blogData object:

const blogData = {
  title: 'Bookmarked: Your Go-To Tool for Curating Tweets in Notion',
  displayedTitle: 'Bookmarked: Your Go-To Tool for\nCurating Tweets in Notion'
}

blogSchema.parse(blogData) // parsed successfully and returns blogData

In the example above, both title and displayedTitle are provided. But what if we don’t want to define both title and displayedTitle manually, especially when they share the same value?

Conditional Defaults with `transform`

We can make the displayedTitle optional and derive it from title when necessary. This way, you only need to provide one value, and the other one is computed automatically.

Here’s how to update the schema:

const blogSchema = z
  .object({
    title: z.string(),
    displayedTitle: z.string().optional() // makes displayedTitle optional
  })
  .transform((data) => ({
    ...data,
    displayedTitle: data.displayedTitle || data.title // fallback to title if displayedTitle is undefined
  }))

Now, if displayedTitle is not provided, it will fall back to using the title property.

For example:

const blogData = {
  title: 'This is the title without linebreak'
}

const parsedData = blogSchema.parse(blogData) // parsed successfully
console.log(parsedData)
// {
//   title: "This is the title without linebreak",
//   displayedTitle: "This is the title without linebreak"
// }

As you can see, displayedTitle is derived from title automatically when it's missing.

Simplifying the Schema with Inferred Values

We can further simplify this by only defining the displayedTitle, and having title inferred automatically by transforming the value. For instance, you might want to replace line breaks (\n) in displayedTitle with spaces in title:

const blogSchema = z
  .object({
    displayedTitle: z.string()
  })
  .transform((data) => ({
    ...data,
    title: data.displayedTitle.replace('\\n', ' ') // removes the linebreaks from title
  }))

const blogData = {
  displayedTitle: 'This is the title\nwith linebreak'
}

const parsedData = blogSchema.parse(blogData) // parsed successfully
console.log(parsedData)
// {
//   title: "This is the title with linebreak",
//   displayedTitle: "This is the title\nwith linebreak"
// }

Here, we’ve reduced the schema to only require displayedTitle, and the title is inferred automatically by removing the \n characters.

Conclusion

Zod allows you to create flexible schemas that validate data and derive properties based on other values. Its transform method offers an elegant solution for handling default values and derived properties efficiently.

Level Up OBS Recordings with Zoom-to-Mouse

Fri, 03 Jan 2025 00:00:00 GMT

import Video from '@/components/Video'

Introduction

Want to make your recordings more dynamic and engaging? Check out the video below to see the zoom-to-mouse effect in action

While paid tools like Screen Studio offer this capability, what if you could achieve the same effect for free? The good news is that you can, using OBS Studio!

In this guide, I'll walk you through the steps to set up zoom-to-mouse functionality. These instructions have been tested on Windows and Mac, and the process should be quite similar for Linux users.

1. Download the Magical Script

To get started, you’ll need to download the script that enables the zoom-to-mouse functionality in OBS Studio

Open this link.
In the Assets section, click to download the obs-zoom-to-mouse.lua file.

2. Set Up Your OBS Screen

Now that you have the script, let’s set up your OBS scene:

Launch OBS.
Add a New Scene by clicking the + button under the Scenes section.
Next, add a New Source:
- On Mac, select macOS Screen Capture as the source.
- On Windows, choose Display Capture as the source.

Important: Not all sources work with this script, so ensure you pick the right one.

3. Setup the zoom to mouse script

Now let’s connect the script to your scene:

Click Tools in the top menu bar.
Select Scripts from the dropdown.
In the Scripts tab, click the plus icon (+) to add the obs-zoom-to-mouse.lua script.
On the right side, you’ll see configuration options. Choose the Zoom Source you created earlier (if you can’t find it, click Refresh zoom sources).

You can adjust the configuration to your liking, but to match the result from my video, here’s the setup:

Tip for Mac Retina Displays: If you're on a Mac with a retina display, you might experience some weird behavior with zoom-to-mouse. To fix this, check the option for Set Manual Source Position and refer to the issue discussion for more details.

For a smoother experience on Retina displays, you can adjust the Scale X and Scale Y to 2, and make sure to set the Monitor Width and Monitor Height based on your screen resolution. Here's my configuration for reference:

4. Setup OBS Hotkey

To control the zoom-to-mouse functionality, you’ll need to configure some hotkeys:

Go to Settings in OBS.
Navigate to the Hotkeys section in the left sidebar.
Search for Toggle zoom to mouse and Toggle follow mouse during zoom.
Assign your preferred hotkeys (I recommend 1 and 2 for easy access).

Setup Global Hotkeys (Mac Only)

For now the hotkeys are only active when OBS is in focus. If you want to use the hotkeys while working in other applications, you need to set up global hotkeys:

Enable Accessibility Permissions
- Open System Settings.
- Navigate to Privacy & Security in the sidebar.
- Click on Accessibility.
- Add OBS to the list of apps that can control your computer.
- Toggle the switch to enable the app.
Allow Input Monitoring
- Back in the Privacy & Security tab, select Input Monitoring.
- Add OBS to the list of apps that can monitor input.
- Toggle the switch to enable the app.

Please note: There is a known issue where this configuration may only work for a few hours. If you encounter this, try restarting your computer to restore functionality. You can read more about this issue here.

And That’s It!

Now you're ready to use the zoom-to-mouse functionality in OBS Studio. Simply press '1' to zoom in and out, and '2' to toggle the zoom following your mouse. This feature can help make your tutorials, presentations, or streams more engaging.

Nate

Hacky Way to Customize Shadcn’s Tooltip Arrows

Introduction

Adding Tooltip Arrows

Adding a Tooltip Border

Naive Approach

Using the stroke Property

Exploring the Drop Shadow Option

Custom SVG Arrow

Positioning

Dynamic Position

Final Result

Conclusion

Setting Dynamic Default Values with Zod Schema

Introduction

Simple Default Value

What If the Default Depends on Another Property?

Conditional Defaults with transform

Simplifying the Schema with Inferred Values

Conclusion

Level Up OBS Recordings with Zoom-to-Mouse

Introduction

1. Download the Magical Script

2. Set Up Your OBS Screen

3. Setup the zoom to mouse script

4. Setup OBS Hotkey

Setup Global Hotkeys (Mac Only)

And That’s It!

Using the `stroke` Property

Conditional Defaults with `transform`