ryangoree

/**
 * A utility type that returns a union of space-separated words in a string.
 * 
 * @example
 * ```ts
 * type Foo = Words<'foo bar baz'>;
 * // => 'foo' | 'bar' | 'baz'
 */
type Words<TString extends string> =
  TString extends `${infer Word} ${infer Rest}` ? Word | Words<Rest> : TString;

ryangoree

/**
 * Converts array or tuple `T` to an object with keys as indices and values as element types.
 * It's handy for when you need type-safe access based on indices, especially with tuples.
 * 
 * `ByIndex` is useful over `{ [K in keyof T]: T[K] }` for:
 * - Keeping index keys as strings for object mapping from tuples.
 * - Handling arrays as tuples for a unified index-based object structure.
 * 
 * Example:
 * type ExampleTuple = ByIndex<[string, number]>; // { "0": string, "1": number }

ryangoree

/**
 * Attempts to get the path to the file that called the function that called
 * this function.
 * @example
 *
 * #### Caller:
 * ```ts
 * // /path/to/file.ts
 * import { foo } from './path/to/foo.ts';
 *

ryangoree

/**
 * Converts a hyphenated string to camel case.
 *
 * @example
 * camelCase('foo-bar') // 'fooBar'
 */
export function camelCase<S>(str: S): CamelCase<S> {
  return (
    typeof str === 'string'
      ? str.toLowerCase().replace(/-+([^-])/g, (_, c) => c.toUpperCase())

ryangoree

import os from "node:os";
import path from "node:path";

/**
 * Get the path to an app specific config directory based on operating system
 * standards.
 * @param projectName
 * @returns
 */
export function getOSConfigDir(projectName: string): string {

ryangoree

/**
 * Conducts a binary search on a sorted array of items to find the index of a
 * specific target. If the target is not found, it returns the nearest index
 * based on the comparator function.
 *
 * @param items - The sorted array of items to search within.
 * @param compare - A comparator function that returns:
 *   - a negative number if `item` is less than the target,
 *   - a positive number if `item` is greater than the target,
 *   - and 0 if `item` is equal to the target.

ryangoree

/**
 * Construct a type based off T where TDefinedField is defined when
 * T matches TDefinedState.
 */
type DefinedWhen<
  T extends Record<string, any>,
  TDefinedField extends keyof T,
  TDefinedState extends Partial<T>,
> =
  | (Omit<T, TDefinedField | keyof TDefinedState> &

ryangoree

type Converted<T, TOriginal, TNew> = T extends TOriginal
  ? TNew
  : T extends Array<infer U>
  ? Converted<U, TOriginal, TNew>[]
  : T extends object
  ? { [K in keyof T]: Converted<T[K], TOriginal, TNew> }
  : T;

function convert<T, TOriginal, TNew>(
  value: T,

ryangoree

/**
 * Format bytes as human-readable text.
 * @param {number} bytes Number of bytes.
 * @param {number} decimalPlaces Number of decimal places to display.
 * @param {number} baseQuantity Number of bytes in a kilobyte.
 * @param {string[]} sizes The unites to use for each power of the baseQuantity.
 * @return {string} Formatted byte size.
 */
export const formatBytes = (
  bytes,

ryangoree

function groupStrings(strings) {
    return Object.values(strings.sort().reduce((a, str) => {
        const s = str.toLowerCase();
        const f = s[0];
        a[f] = a[f] ? [...a[f], s] : [s];
        return a;
    }, {}));
}