https://github.com/WesleyAC/deeplinks

been curious for a while

thoughts:

• maybe try out in bic first? Pinjasaur/bic-example#13
• which pages to include on? only entries? probably fair

Would like a scripts/lint.sh to do some basic linting on posts. Things like spelling and grammar. Also, checking external links if that's not a huge PITA.

I think I can simply start with proselint and that'll do enough to start. Plus, I've wanted to try it out for a while, see: https://paul.af/fosdem-2021

I'd like to try out Nix for this as well, using the #! nix-shell shebang:

• https://nix.dev/tutorials/first-steps/reproducible-scripts
• https://search.nixos.org/packages?channel=23.05&from=0&size=50&sort=relevance&type=packages&query=proselint

Huge fan of the column-based layout: http://www.craftinginterpreters.com/local-variables.html

1. use an id if it's already present (pandoc seems to generate 'em consistently)
2. if it doesn't exist, generate one but try to keep it clean and avoid appending any unique numbers unless it's required

I used this strategy on other projects e.g. https://github.com/Pinjasaur/bic-example/blob/3f6c59b948d8346e0ce1feb095bf97a1521fa0ef/static/js/script.js

Currently import cuetip but could do better with how it's themed for the blog and likely dropping the use of the tails/triangles as the math for aligning them is finnicky across fonts and font sizes.

Starting with a customize request payload of:

{
  "vars": {
    "namespace": {
      "value": "tooltip",
      "type": "string"
    },
    "class-prefix": {
      "value": "tooltip--",
      "type": "string"
    },
    "no-tail": {
      "value": "no-tail",
      "type": "string"
    },
    "default-position": {
      "value": "top",
      "type": "string"
    },
    "has-tail": {
      "value": "false",
      "type": "boolean"
    },
    "cursor": {
      "value": "inherit",
      "type": "keyword"
    },
    "z-index": {
      "value": "9999",
      "type": "number"
    },
    "color-foreground": {
      "value": "var(--bg)",
      "type": "color"
    },
    "color-background": {
      "value": "var(--accent)",
      "type": "color"
    },
    "padding": {
      "value": ".25em .4em",
      "type": "units"
    },
    "border-radius": {
      "value": "2px",
      "type": "units"
    },
    "tail-size": {
      "value": ".25em",
      "type": "units"
    },
    "offset": {
      "value": ".1em",
      "type": "units"
    }
  }
}

and then supplement with a few additional lines of CSS should be a good starting point I would think:

[data-tooltip] {
  text-decoration: underline dotted;
}
abbr[data-tooltip] {
  cursor: help;
}
[data-tooltip]:after {
  font-size: 1em;
  opacity: .9;
}

There's a much larger conversation to be had w.r.t. a11y i.e., using aria-label (see Pinjasaur/cuetip#3). I'm not sure how much benefit I'm necessarily gaining over the builtin footnotes and attr[title] markup.

Using https://o9s.xyz/readtime as a reference, add the read-time to articles.

$(".entry").text().match(/[^\s]+/g).length

Seems to work decently.

I think I ultimately only care about internal 404s. I generally do a best-effort when hyperlinking i.e. deeplink to Git commits or Archive.org snapshots.

Kagi's FastGPT:

write me a shell script to check for internal 404s by crawling a given domain

Output:

Here is a shell script that can be used to check for internal 404 errors on a given domain:

#!/bin/bash

# Usage: ./check_404.sh <domain>
domain=$1

# Check if a domain was provided
if [ -z "$domain" ]; then
    echo "Usage: $0 <domain>"
    exit 1
fi

# Set the output file name
output_file="404_errors_$domain.txt"

# Crawl the website and save the output
wget --spider --recursive --level=5 --no-verbose --output-file=$output_file $domain 2>&1 | grep "404 Not Found"

# Check the output file for 404 errors
if [ -s "$output_file" ]; then
    echo "The following internal 404 errors were found on $domain:"
    cat $output_file
else
    echo "No internal 404 errors were found on $domain."
fi

# Clean up the output file
rm $output_file

Here's how the script works:

The script takes a domain as a command-line argument.
It sets the output file name based on the domain.
It uses the wget command to crawl the website recursively up to 5 levels, and saves the output to the output file.
The script then searches the output file for any lines containing "404 Not Found", which indicates a 404 error.
If any 404 errors are found, the script prints them to the console. Otherwise, it prints a message indicating that no 404 errors were found.
Finally, the script deletes the output file.

To use the script, save it to a file (e.g., check_404.sh) and make it executable with chmod +x check_404.sh. Then, run the script with the domain as an argument:

./check_404.sh example.com

This will check the example.com domain for internal 404 errors and print the results to the console.

Note that this script only checks for internal 404 errors (i.e., errors on pages within the same domain). To check for external 404 errors (i.e., broken links to other domains), you may need to use a more sophisticated tool or a different approach.

Shortcut breakdown:

• h next post
• j scroll down
• k scroll up
• l prev post

Could store setting for shortcuts are enabled in localStorage, similar to the site theme.

As per http://clagnut.com/blog/2395 update the lang attr on <html> and add the necessary CSS.