
Did you know that you can use [`closest`](https://developer.mozilla.org/en-US/docs/Web/API/Element/closest) to find an element's nearest ancestor that matches a specific selector (including the element itself, which it checks first)?

```jsx
<article class="post">
  <div class="content">
    <h1 class="title">hello</h1>
    <div class="cta">
      <p>call to action</p>
      <button id="button">click me</button>
    </div>
  </div>
</article>

const button = document.querySelector('#button')
// Find the nearest article ancestor
const article = button.closest('article')
// Find the nearest element with class 'content'
const content = button.closest('.content')
```

There is also [matches](https://developer.mozilla.org/en-US/docs/Web/API/Element/matches) for checking if an element matches a selector. This is useful for conditional logic based on element properties.

```js
const button = document.querySelector("#button");

// Check if the button is inside an article
if (button.closest("article")?.matches(".post")) { ... }

// Check if the button itself has specific classes
if (button.matches(".cta button")) { ... }
```


2025-05-09


Today I discovered `go doc <type|func|pkg>`; a useful tool for learning about the Go standard library or anything in your own project.

```shell
go help doc
```

```shell
# Example 1: Standard library function
go doc json.decode

package json // import "encoding/json"

func (dec *Decoder) Decode(v any) error
    Decode reads the next JSON-encoded value from its input and stores it in the
    value pointed to by v.
...

# Example 2: Your own project
cd path/to/project/types
go doc HomePageAsset
...
type HomePageAsset struct {
	NotionFiles []notionapi.File `json:"notionFiles,omitempty"`
	UUID        string           `json:"uuid,omitempty"`
	Type        string           `json:"type,omitempty"`
	Files       []File           `json:"files,omitempty"`
	Align       string           `json:"align,omitempty"`
	Width       int              `json:"width,omitempty"`
}
```

I don't do as much Go development these days but I always enjoy finding new tools in Go's standard tooling. Unlike some languages that require external tools or web browsers to access documentation, Go's approach of embedding documentation in the command line makes the development experience more efficient. This is especially helpful when working offline or when you need quick reference.

There is also [`godoc`](https://pkg.go.dev/golang.org/x/tools/cmd/godoc) for serving your own documentation.


2025-04-19


`|` means "literal block scalar", which produces a multiline string with no special formatting

```yaml
run:
  command: |
    npm run dev
    npm run test
```

translates to:

`npm run dev\nnpm run test`

The cool one I learned about today is `>-`, a "folded block scalar". It preserves line breaks as spaces (folding them into a single line). The `-` modifier tells YAML to "chomp" (remove) any trailing newlines at the end of the block.

### Example YAML

```yaml
services:
  postgres:
    image: postgres
    restart: always
    options: >-
      --health-cmd pg_isready
      --health-interval 10s
      --health-timeout 5s
      --health-retries 5
```

translates to

```shell
... --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
```


Blog.

Today I Learned

Today I Learned