ryangoree

// A conditional type only distributes over unions that are:
// - On the left side of `extends` (the checked type).
// - Generic type variables (introduced via `infer` or generic type parameters).
// - Naked (not wrapped in another type).
//
// See:
// - https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#distributive-conditional-types
// - https://www.typescriptlang.org/docs/handbook/2/conditional-types.html#inferring-within-conditional-types

type U = 1 | "a";

ryangoree

# ANSI Select Graphic Rendition (SGR) Formatting Syntax:
#
#   ESC [ Ps [; Ps]* m
#
# Where:
#   ESC = '\033' (octal) / '\u001b' (unicode) / '\x1b' (hex)
#   '[' = Control Sequence Introducer (CSI)
#   Ps  = one or more numeric parameters Values(e.g. '1', '2', '31', '44')
#
# Example: '\033[4;31mHello\033[0m' → underlined (4) red (31) 'Hello'

ryangoree

import assert from "node:assert";
import { describe, it } from "node:test";
import { evaluate } from "./mathEvaluator.ts";

describe("evaluate", () => {
  it("evaluates single numbers", () => {
    assert.strictEqual(evaluate("1"), 1);
    assert.strictEqual(evaluate("12"), 12);
    assert.strictEqual(evaluate("12.34"), 12.34);
    assert.strictEqual(evaluate(".12"), 0.12);

ryangoree

/**
 * One of the *explicit* property names of {@linkcode T}, with any `string` or
 * `number` index signatures stripped out.
 *
 * @example
 * ```ts
 * type A = LiteralKey<{
 *   [k: string]: any;
 *   id: string;

ryangoree

//--- Tuple operations ---//

type BuildTuple<
  L extends number,
  T extends any[] = [],
  F = unknown,
> = `${L}` extends `-${number}`
  ? never
  : T["length"] extends L
    ? T

ryangoree

import { readdirSync, readFileSync, statSync } from "node:fs";
import { join } from "node:path";

export function recursiveRead({
  entryPath,
  onDirectory,
  onDirectoryExit,
  onFile,
  onError,
}: {

ryangoree

ANSI Escape Sequences

Standard escape codes are prefixed with Escape:

• Ctrl-Key: ^[
• Octal: \033
• Unicode: \u001b
• Hexadecimal: \x1B
• Decimal: 27

ryangoree

/**
 * Get {@linkcode T}, ensuring that all keys from {@linkcode K} are present. If
 * any keys are missing, a type error will be thrown.
 *
 * @typeParam K - The keys to ensure are present.
 * @typeParam T - An object that should contain all keys from {@linkcode K}.
 * @typeParam TDefault - The default value to use for missing keys.
 *
 * @example
 * ```ts

ryangoree

/**
 * Extracts and transforms members of a union type `T` based on a filter type
 * `F`. It's similar to `Extract<T, U>` but rather than omitting members of `T`
 * that aren't wholly assignable to `U`, (e.g., omitting `{ a: string }` when
 * `U` is `{ a: 'foo' }`), it narrows values of `T` that the filter type `F` is
 * assignable to (e.g., `{ a: string }` is narrowed to `{ a: 'foo' }`).
 *
 * For each member in `T` (distributing over unions), if it includes all
 * required keys (as determined by {@linkcode RequiredValueKey<F>}), the type is
 * transformed by applying the filter:

ryangoree

/**
 * Get a union of value types for `T` by unwrapping it recursively.
 *
 * @example
 * ```ts
 * type Scalar = string;
 * type ScalarValue = DeepValue<Scalar>;
 * // => string
 *
 * type NestedArray = [string, [number, [boolean]]];