CMCDragonkai

There are number of ways of creating tagged unions.

type X = { type: A, prop: number } | { type: B, prop: string };

type Y = { type: A, data: { prop: number } } | { type: B, data: { prop: string } };

type Z = ['A', { prop: number }] | ['B', { prop: string }];

CMCDragonkai

import * as nobleEd25519 from '@noble/ed25519';

/**
 * Checks if the public key is a point on the Ed25519 curve
 */
function validatePublicKey(publicKey: Buffer): boolean {
  try {
    nobleEd25519.Point.fromHex(publicKey);
    return true;
  } catch {

CMCDragonkai

/**
 * Webcrypto random bytes is limited to 65,536 in one call.
 * The below functions will make repeated calls to acquire random bytes.
 */

const webcrypto = globalThis.crypto?.webcrypto || globalThis.window?.crypto;

async function sleep(ms: number): Promise<void> {
  return await new Promise<void>((r) => setTimeout(r, ms));
}

CMCDragonkai

#!/usr/bin/env bash

set -o errexit
set -o nounset
set -o pipefail
shopt -s inherit_errexit

count=0

glab api 'projects/:fullpath/issues?state=opened' --paginate | jq -c '.[]' | while read -r issue_object; do

CMCDragonkai

Imagine this...

async function main () {
  const config = await (async (
    a = 'a',
    b = 'b',
    c = `${a}/${b}`,
    d = ((
 e = 'e',

CMCDragonkai

Reload the DNS Cache in Network Manager

You may be using NetworkManager with dnsmasq as the DNS plugin. If so, it's being used as a local caching nameserver.

When its data is outdated, you can force it to reload its DNS cache with:

Use:

nmcli general reload dns-full

CMCDragonkai

Compound Growth (Interest) Rate

Suppose something grew 300% over 20 years, and you want to know what was the annual growth rate.

Use the compound interest rate formula:

A = P(1 + r/n)^(n*t)

CMCDragonkai

import { CustomError } from 'ts-custom-error';

class ErrorParse extends CustomError {
  public readonly errors: Array<ErrorRule>;
  constructor(errors: Array<ErrorRule>) {
    const message = errors.map((e) => e.message).join('; ');
    super(message);
    this.errors = errors;
  }
}

CMCDragonkai

import { EventEmitter } from 'events';

class EventBus extends EventEmitter {

  protected kCapture: symbol;

  constructor (...args: ConstructorParameters<typeof EventEmitter>) {
    super(...args);
    // EventEmitter's captureRejections option is only accessible through a private symbol
    // Here we augment the construction and save it as a property

CMCDragonkai

import crypto from 'crypto';

/**
 * Gets random bytes as Uint8Array
 */
function randomBytes(size: number): Uint8Array {
  return crypto.randomBytes(size);
}

/**