I use Emacs’s built-in project.el to manage projects, and .env or .envrc files to manage environment variables for those projects. Those files are usually not tracked by git, so project-file-file doesn’t offer them as optionsInvoking project-find-file with a prefix argument will find uncommitted files, but also all other files that have been added to .gitignore, which I don’t want.

, so I wrote a small function that will find all .env and .envrc files (including files with suffixes, like .env.local and .envrc.sample) in the project root:

(defun ps/project-find-dotenv-file ()
  (interactive)
  (let* ((project           (project-current t))
         (default-directory (project-root project))
         (files             (file-expand-wildcards "\\`.env\\(rc\\)?\\(\\..+\\)?\\'" nil t))
         (completion        (lambda (str pred flag)
                              (pcase flag
                                ('metadata
                                 `(metadata (category . file)))
                                (_
                                 (all-completions str files pred)))))
         (file              (completing-read "Find .env/.envrc file: " completion)))
    (find-file file)))

completion could be a simple list of strings instead of a lambda, but I use marginalia to annotate completions with useful information, which requires that the category metadata be set on completions so that it knows that (in this case) it should treat the completions as files when annotating them.

I bind it in project-prefix-map and also add it to the project switcher:

(use-package project
  :ensure nil
  :init
  (setq project-switch-commands '((magit-project-status        "Magit")
                                  (project-find-file           "Find file")
                                  (ps/project-find-dotenv-file "Find .env file")))
  :bind
  (:map project-prefix-map
        ("m" . magit-project-status)
        ("v" . ps/project-find-dotenv-file)))

I’m running Wayland on NixOS using Nvidia graphics. 1PasswordAvailable in the _1password-gui package.

is not compatible by default with that setup and starts up with a black window:

1Password support suggests running 1Password with the --disable-gpu-sandbox option, which works from the command line, but to use that option when launching 1Password with the GNOME launcher, we need to edit the .desktop file that’s included with the package. Since that file is immutable in NixOS, I wrote an overlayBased on a comment in the NixOS subreddit.

for the _1password-gui package which overrides that file.

In my home-managerYou should be able to do something similar if you are using NixOS to install 1Password for the entire system, instead of using home-manager.

config:

nixpkgs.overlays = [ (import ./overlays/1password.nix) ];

… and in overlays/1password.nix:

final: prev: {
  _1password-gui = prev._1password-gui.overrideAttrs (oldAttrs: {
    postInstall = (oldAttrs.postInstall or "") + ''
      substituteInPlace $out/share/applications/1password.desktop \
        --replace "Exec=1password" "Exec=1password --disable-gpu-sandbox"
    '';
  });
}

We can see the result of the override by inspecting ~/.nix-profile/share/applications/1password.desktop, which is symlinked to the .desktop file in the Nix store.

[Desktop Entry]
Name=1Password
Exec=1password --disable-gpu-sandbox %U
Terminal=false
Type=Application
Icon=1password
StartupWMClass=1Password
Comment=Password manager and secure wallet
MimeType=x-scheme-handler/onepassword;
Categories=Office;

The file looks correct and 1Password works after being launched from the GNOME launcher:1Password doesn’t quit when the window is closed, so if you already have an instance running without the necessary option, you may need to killall 1password to shut it down before launching it again.

I’m working on a project using Shortcut, where every commit message must include the ID of a Shortcut story, in this format:

[sc-12345] Commit message

I wanted to be able to quickly open a Shortcut story in a browser from the ID. Since I use Embark in Emacs, I created a new “target finder” which converts text like [sc-12345] into a URL, and added it to embark-target-finders. The target finder is based on the “short Wikipedia links” example in the Embark manual. You can find it at info:(embark) New target example in regular buffers - short Wikipedia links.

(defvar ps/embark-target-shortcut-story-workspace nil
  "The Shortcut workspace used when creating story URLs.")

(defconst ps/embark-target-shortcut-story--start-end-regexp
  "SCsc\\-[0-9]+"
  "The regexp used to find the beginning and end of Shortcut story IDs.")

(defun ps/embark-target-shortcut-story ()
  "Target a Shortcut story ID at point of the form sc-[story-id].

`ps/embark-target-shortcut-story-workspace' must be set or this
function will return nil."
  (when ps/embark-target-shortcut-story-workspace
    (save-excursion
      (let* ((start (progn
                      (skip-chars-backward ps/embark-target-shortcut-story--start-end-regexp)
                      (point)))
             (end   (progn
                      (skip-chars-forward ps/embark-target-shortcut-story--start-end-regexp)
                      (point)))
             (str   (buffer-substring-no-properties start end)))
        (save-match-data
          (when (string-match "sc-\\([0-9]+\\)" str)
            `(url
              ,(format "https://app.shortcut.com/%s/story/%s"
                       ps/embark-target-shortcut-story-workspace
                       (match-string 1 str))
              ,start . ,end)))))))

(add-to-list 'embark-target-finders 'ps/embark-target-shortcut-story)

When looking at Git logs, or in any other buffer, I can invoke embark-dwim when the point is on a Shortcut story ID, and it will open in my browser.

Since Shortcut story URLs include a workspace name, you must set ps/embark-target-shortcut-story-workspace for the target finder to generate a URL. For example, if ps/embark-target-shortcut-story-workspace is set to "my-workspace", and the point is on the story ID [sc-12345], embark-dwim will open https://app.shortcut.com/my-workspace/story/12345 in your browser.

I often compile projects in Emacs using project-compile, and then don’t notice that they finished because the compilation window is no longer visible, so I added the following code to my config. It adds a hook to compilation-mode which alerts me when compilation finishes, only if the compilation buffer is not visible in a focused frame. It requires the alert package.

(defun ps/buffer-visible-in-focused-frame-p (buffer)
  "Return t if BUFFER is visible in the focused frame, or nil otherwise."
  (let ((windows (get-buffer-window-list buffer nil t)))
    (cl-some (lambda (window)
               (and (window-live-p window)
                    (frame-focus-state (window-frame window))))
             windows)))

(defun ps/compilation-finish-alert (buffer result)
  "Alert the user when a compilation buffer finishes.

If the compilation buffer is visible in the focused frame, the
user will not be alerted."
  (unless (ps/buffer-visible-in-focused-frame-p buffer)
    (alert (format "Compilation %s" result)
           :id (format "ps/compilation-finish-alert-" (buffer-name buffer))
           :never-persist t
           :buffer buffer)))

(add-hook 'compilation-finish-functions 'ps/compilation-finish-alert)

Making XMonad work smoothly with Zoom takes some configuration. Here are some problems I’ve run into, with the solutions I’ve found.

Screen Sharing

If Zoom doesn’t give you the option to share individual windows when screen sharing, you need to use ewmh from XMonad.Hooks.EwmhDesktops.Reddit: xmonad window sharing with Zoom

If the “You are screen sharing” / “Stop Share” controls which appear at the top of the screen when you are screen sharing have a black background, and sometimes disappear when you change windows, you need to use a compositor. I use picom.

Floating Notification Windows

Zoom shows notification windows when you join audio (eg. “You are connected to computer audio”) and when people start screen sharing. By default, these windows will be tiled, but they should be floated. Because many of the windows change their title shortly after they are created, matching by title in a custom manageHook doesn’t work, since that doesn’t watch for changes to window titles. Instead, you need to also observe window title changes using XMonad.Hooks.DynamicProperty.Ethan Schoonover on the Arch Linux forums

I have a single manageZoomHook which I include in both my custom manageHook and my custom handleEventHook (using dynamicTitle from XMonad.Hooks.DynamicProperty):

manageZoomHook =
  composeAll $
    [ (className =? zoomClassName) <&&> shouldFloat <$> title --> doFloat,
      (className =? zoomClassName) <&&> shouldSink <$> title --> doSink
    ]
  where
    zoomClassName = "zoom"
    tileTitles =
      [ "Zoom - Free Account", -- main window
        "Zoom - Licensed Account", -- main window
        "Zoom", -- meeting window on creation
        "Zoom Meeting" -- meeting window shortly after creation
      ]
    shouldFloat title = title `notElem` tileTitles
    shouldSink title = title `elem` tileTitles
    doSink = (ask >>= doF . W.sink) <+> doF W.swapDown

myManageHook =
  manageZoomHook
    <+> manageDocks
    <+> manageHook defaultConfig

myHandleEventHook =
  mconcat
    [ dynamicTitle manageZoomHook,
      docksEventHook,
      handleEventHook defaultConfig
    ]

When I’m working in Emacs, I use vterm as a terminal emulator. Rather than use a separate terminal emulator when I’m not already in Emacs, I’d like to be able to easily open a new Emacs frame with a fresh terminal in it. To do that, I wrote a script which runs emacsclientThis requires that you are running Emacs as a daemon.

, opens a new frame, and launches vterm:

emacsclient -cn --eval "(progn (x-focus-frame nil) (vterm t))"

• -cn creates a new frame, but does not wait for it to close before finishing the script.
• (x-focus-frame nil) focuses the new frame. On macOS, the new frame will often appear in the background without this.
• (vterm t) creates a new vterm buffer. Without the t argument, it would switch to an already-existing vterm buffer, if there was one.

On Linux, with XMonad as my window manager, I bind this script to S-s-<return>. On macOS, I use Alfred to bind it to ⇧⌘⏎.Alfred runs the script from the path of the workflow that contains it, so I add cd ~ to the beginning of the script on macOS.

I recently came across a situation where I needed to write a very long conditional typeConditional types have the format T extends U ? X : Y. Read more about them in the TypeScript docs.

that looked something like this:

Rather than nesting extends expressions, which only supports a fixed number of conditions and results in a pyramid of doom in the definition of Foo, this could be better expressed using a Switch type:

type Switch<Value, [
  [Match1, Result1],
  [Match2, Result2],
  [Match3, Result3],
  ...
]> = ...

type Test1 = Switch<string, [
  [number, "number"],
  [boolean, "boolean"],
  [string, "string"]
]>;
// Test1 = "string"

Switch supports an arbitrary number of conditions, and we can write a recursive definition for it.

Defining Switch

To iterate through the array of conditions, I use the List.Head and List.Tail types from the excellent ts-toolbelt library:

import {List} from 'ts-toolbelt';

type Test1 = List.Head<[boolean, string, number]>;
// Test1 = boolean

type Test2 = List.Tail<[boolean, string, number]>;
// Test2 = [string, number]

Using Head and Tail, we can define Switch like this:

type Switch<T, Conditions extends Array<[any, any]>> = 
  List.Head<Conditions> extends never
    ? never
    : T extends List.Head<Conditions>[0]
      ? List.Head<Conditions>[1]
      : Switch<T, List.Tail<Conditions>>;

We can confirm that it works with a few test types:

type Test1 = Switch<string, [
  [number, "number"],
  [boolean, "boolean"],
  [string, "string"]
]>;
// Test1 = "string"

type Test2 = Switch<object, [
  [number, "number"],
  [boolean, "boolean"],
  [string, "string"]
]>;
// Test2 = never

type Test3 = Switch<string, []>;
// Test3 = never

To add a default case, match against any in the last condition:

type Test1 = Switch<string, [
  [number, "number"],
  [any, "default case"]
]>;
// Test1 = "default case"

For explanations of conditional types, implementing recursive types, and other advanced type techniques, check out these articles:

• Advanced Types in the TypeScript docs
• How to master advanced TypeScript patterns by Pierre-Antoine Mills (the author of ts-toolbelt)