@oh-my-pi/pi-utils 17.2.9 → 17.2.11

package/src/chalk.ts

@@ -0,0 +1,312 @@
+/** Behavior-compatible reimplementation of chalk's used surface. */
+
+import { hexToRgb } from "./color";
+
+/** ANSI color capability level. */
+export type ColorLevel = 0 | 1 | 2 | 3;
+
+/** Details about a terminal's supported color depth. */
+export interface ColorSupport {
+	/** Highest supported ANSI color level. */
+	level: ColorLevel;
+	/** Whether the terminal supports the basic 16 colors. */
+	hasBasic: boolean;
+	/** Whether the terminal supports the 256-color palette. */
+	has256: boolean;
+	/** Whether the terminal supports 24-bit color. */
+	has16m: boolean;
+}
+
+interface ChalkOptions {
+	level?: ColorLevel;
+}
+
+interface Style {
+	open: string;
+	close: string;
+}
+
+interface ChalkContext {
+	level: number;
+}
+
+/** A callable, chainable ANSI text formatter. */
+export interface ChalkInstance {
+	(...text: unknown[]): string;
+	/** Active color capability level. */
+	level: ColorLevel;
+	/** Reset every active terminal style. */
+	readonly reset: ChalkInstance;
+	/** Render bold text. */
+	readonly bold: ChalkInstance;
+	/** Render faint text. */
+	readonly dim: ChalkInstance;
+	/** Render italic text. */
+	readonly italic: ChalkInstance;
+	/** Render underlined text. */
+	readonly underline: ChalkInstance;
+	/** Swap foreground and background colors. */
+	readonly inverse: ChalkInstance;
+	/** Render struck-through text. */
+	readonly strikethrough: ChalkInstance;
+	/** Render black text. */
+	readonly black: ChalkInstance;
+	/** Render red text. */
+	readonly red: ChalkInstance;
+	/** Render green text. */
+	readonly green: ChalkInstance;
+	/** Render yellow text. */
+	readonly yellow: ChalkInstance;
+	/** Render blue text. */
+	readonly blue: ChalkInstance;
+	/** Render magenta text. */
+	readonly magenta: ChalkInstance;
+	/** Render cyan text. */
+	readonly cyan: ChalkInstance;
+	/** Render white text. */
+	readonly white: ChalkInstance;
+	/** Render gray text. */
+	readonly gray: ChalkInstance;
+	/** Alias for gray text. */
+	readonly grey: ChalkInstance;
+	/** Render bright black text. */
+	readonly blackBright: ChalkInstance;
+	/** Render bright red text. */
+	readonly redBright: ChalkInstance;
+	/** Render bright green text. */
+	readonly greenBright: ChalkInstance;
+	/** Render bright yellow text. */
+	readonly yellowBright: ChalkInstance;
+	/** Render bright blue text. */
+	readonly blueBright: ChalkInstance;
+	/** Render bright magenta text. */
+	readonly magentaBright: ChalkInstance;
+	/** Render bright cyan text. */
+	readonly cyanBright: ChalkInstance;
+	/** Render bright white text. */
+	readonly whiteBright: ChalkInstance;
+	/** Render text on a black background. */
+	readonly bgBlack: ChalkInstance;
+	/** Render text on a red background. */
+	readonly bgRed: ChalkInstance;
+	/** Render text on a green background. */
+	readonly bgGreen: ChalkInstance;
+	/** Render text on a yellow background. */
+	readonly bgYellow: ChalkInstance;
+	/** Render text on a blue background. */
+	readonly bgBlue: ChalkInstance;
+	/** Render text on a magenta background. */
+	readonly bgMagenta: ChalkInstance;
+	/** Render text on a cyan background. */
+	readonly bgCyan: ChalkInstance;
+	/** Render text on a white background. */
+	readonly bgWhite: ChalkInstance;
+	/** Render text on a gray background. */
+	readonly bgGray: ChalkInstance;
+	/** Alias for a gray background. */
+	readonly bgGrey: ChalkInstance;
+	/** Render text on a bright black background. */
+	readonly bgBlackBright: ChalkInstance;
+	/** Render text on a bright red background. */
+	readonly bgRedBright: ChalkInstance;
+	/** Render text on a bright green background. */
+	readonly bgGreenBright: ChalkInstance;
+	/** Render text on a bright yellow background. */
+	readonly bgYellowBright: ChalkInstance;
+	/** Render text on a bright blue background. */
+	readonly bgBlueBright: ChalkInstance;
+	/** Render text on a bright magenta background. */
+	readonly bgMagentaBright: ChalkInstance;
+	/** Render text on a bright cyan background. */
+	readonly bgCyanBright: ChalkInstance;
+	/** Render text on a bright white background. */
+	readonly bgWhiteBright: ChalkInstance;
+	/** Render text with an arbitrary hexadecimal foreground color. */
+	hex(color: string): ChalkInstance;
+}
+
+/** Constructor for an independently configured chalk formatter. */
+export interface ChalkConstructor {
+	new (options?: ChalkOptions): ChalkInstance;
+}
+
+const ESC = "\u001B[";
+const STYLES: Readonly<Record<string, Style>> = {
+	reset: { open: `${ESC}0m`, close: `${ESC}0m` },
+	bold: { open: `${ESC}1m`, close: `${ESC}22m` },
+	dim: { open: `${ESC}2m`, close: `${ESC}22m` },
+	italic: { open: `${ESC}3m`, close: `${ESC}23m` },
+	underline: { open: `${ESC}4m`, close: `${ESC}24m` },
+	inverse: { open: `${ESC}7m`, close: `${ESC}27m` },
+	strikethrough: { open: `${ESC}9m`, close: `${ESC}29m` },
+	black: { open: `${ESC}30m`, close: `${ESC}39m` },
+	red: { open: `${ESC}31m`, close: `${ESC}39m` },
+	green: { open: `${ESC}32m`, close: `${ESC}39m` },
+	yellow: { open: `${ESC}33m`, close: `${ESC}39m` },
+	blue: { open: `${ESC}34m`, close: `${ESC}39m` },
+	magenta: { open: `${ESC}35m`, close: `${ESC}39m` },
+	cyan: { open: `${ESC}36m`, close: `${ESC}39m` },
+	white: { open: `${ESC}37m`, close: `${ESC}39m` },
+	gray: { open: `${ESC}90m`, close: `${ESC}39m` },
+	blackBright: { open: `${ESC}90m`, close: `${ESC}39m` },
+	redBright: { open: `${ESC}91m`, close: `${ESC}39m` },
+	greenBright: { open: `${ESC}92m`, close: `${ESC}39m` },
+	yellowBright: { open: `${ESC}93m`, close: `${ESC}39m` },
+	blueBright: { open: `${ESC}94m`, close: `${ESC}39m` },
+	magentaBright: { open: `${ESC}95m`, close: `${ESC}39m` },
+	cyanBright: { open: `${ESC}96m`, close: `${ESC}39m` },
+	whiteBright: { open: `${ESC}97m`, close: `${ESC}39m` },
+	bgBlack: { open: `${ESC}40m`, close: `${ESC}49m` },
+	bgRed: { open: `${ESC}41m`, close: `${ESC}49m` },
+	bgGreen: { open: `${ESC}42m`, close: `${ESC}49m` },
+	bgYellow: { open: `${ESC}43m`, close: `${ESC}49m` },
+	bgBlue: { open: `${ESC}44m`, close: `${ESC}49m` },
+	bgMagenta: { open: `${ESC}45m`, close: `${ESC}49m` },
+	bgCyan: { open: `${ESC}46m`, close: `${ESC}49m` },
+	bgWhite: { open: `${ESC}47m`, close: `${ESC}49m` },
+	bgBlackBright: { open: `${ESC}100m`, close: `${ESC}49m` },
+	bgRedBright: { open: `${ESC}101m`, close: `${ESC}49m` },
+	bgGreenBright: { open: `${ESC}102m`, close: `${ESC}49m` },
+	bgYellowBright: { open: `${ESC}103m`, close: `${ESC}49m` },
+	bgBlueBright: { open: `${ESC}104m`, close: `${ESC}49m` },
+	bgMagentaBright: { open: `${ESC}105m`, close: `${ESC}49m` },
+	bgCyanBright: { open: `${ESC}106m`, close: `${ESC}49m` },
+	bgWhiteBright: { open: `${ESC}107m`, close: `${ESC}49m` },
+};
+
+function parseForcedLevel(value: string | undefined): ColorLevel | undefined {
+	if (value === undefined) return undefined;
+	if (value === "" || value === "true") return 1;
+	if (value === "false") return 0;
+	const parsed = Number.parseInt(value, 10);
+	if (Number.isNaN(parsed)) return 1;
+	return Math.max(0, Math.min(3, parsed)) as ColorLevel;
+}
+
+/** Detect an ANSI color level from terminal environment and TTY state. */
+export function detectColorLevel(environment: NodeJS.ProcessEnv, isTTY: boolean): ColorLevel {
+	const forced = parseForcedLevel(environment.FORCE_COLOR);
+	if (forced !== undefined) return forced;
+	if ("NO_COLOR" in environment || environment.TERM === "dumb") return 0;
+	if (!isTTY) return 0;
+	if (environment.COLORTERM === "truecolor" || environment.COLORTERM === "24bit") return 3;
+	if (environment.TERM?.endsWith("-256color")) return 2;
+	if (environment.CI) {
+		if (environment.GITHUB_ACTIONS || environment.GITEA_ACTIONS) return 3;
+		if (
+			environment.TRAVIS ||
+			environment.CIRCLECI ||
+			environment.APPVEYOR ||
+			environment.GITLAB_CI ||
+			environment.BUILDKITE
+		) {
+			return 1;
+		}
+		return 0;
+	}
+	if (environment.TERM_PROGRAM === "iTerm.app") {
+		return Number.parseInt(environment.TERM_PROGRAM_VERSION ?? "0", 10) >= 3 ? 3 : 2;
+	}
+	if (environment.TERM_PROGRAM === "Apple_Terminal") return 2;
+	return 1;
+}
+
+function colorSupport(level: ColorLevel): ColorSupport | false {
+	if (level === 0) return false;
+	return { level, hasBasic: true, has256: level >= 2, has16m: level >= 3 };
+}
+
+/** Color support detected for standard output. */
+export const supportsColor = colorSupport(detectColorLevel(process.env, Boolean(process.stdout.isTTY)));
+
+/** Color support detected for standard error. */
+export const supportsColorStderr = colorSupport(detectColorLevel(process.env, Boolean(process.stderr.isTTY)));
+
+function ansi256(r: number, g: number, b: number): number {
+	if (r === g && g === b) {
+		if (r < 8) return 16;
+		if (r > 248) return 231;
+		return Math.round(((r - 8) / 247) * 24) + 232;
+	}
+	return 16 + 36 * Math.round((r / 255) * 5) + 6 * Math.round((g / 255) * 5) + Math.round((b / 255) * 5);
+}
+
+function ansi16(r: number, g: number, b: number): number {
+	const value = Math.max(r, g, b);
+	if (value < 50) return 30;
+	let code = 30 + ((Math.round(b / 255) << 2) | (Math.round(g / 255) << 1) | Math.round(r / 255));
+	if (value > 191) code += 60;
+	return code;
+}
+
+function hexStyle(color: string, level: number): Style {
+	const { r, g, b } = hexToRgb(color);
+	const open =
+		level >= 3
+			? `${ESC}38;2;${r};${g};${b}m`
+			: level === 2
+				? `${ESC}38;5;${ansi256(r, g, b)}m`
+				: `${ESC}${ansi16(r, g, b)}m`;
+	return { open, close: `${ESC}39m` };
+}
+
+function applyStyles(input: string, styles: readonly Style[]): string {
+	let output = input;
+	let opening = "";
+	let closing = "";
+	for (let index = styles.length - 1; index >= 0; index--) {
+		const style = styles[index];
+		if (!style) continue;
+		output = output.split(style.close).join(style.close + style.open);
+		opening = style.open + opening;
+		closing += style.close;
+	}
+	output = output.replace(/\r?\n/g, match => `${closing}${match}${opening}`);
+	return opening + output + closing;
+}
+
+function createBuilder(context: ChalkContext, styles: readonly Style[]): ChalkInstance {
+	const builder = ((...values: unknown[]) => {
+		let text = "";
+		for (let index = 0; index < values.length; index++) {
+			if (index > 0) text += " ";
+			text += String(values[index]);
+		}
+		if (text.length === 0 || context.level === 0) return text;
+		return applyStyles(text, styles);
+	}) as ChalkInstance;
+	Object.defineProperty(builder, "level", {
+		get: () => context.level,
+		set: (level: number) => {
+			context.level = level;
+		},
+	});
+	for (const name in STYLES) {
+		const style = STYLES[name];
+		if (style) Object.defineProperty(builder, name, { get: () => createBuilder(context, [...styles, style]) });
+	}
+	Object.defineProperty(builder, "grey", { get: () => createBuilder(context, [...styles, STYLES.gray!]) });
+	Object.defineProperty(builder, "bgGray", {
+		get: () => createBuilder(context, [...styles, STYLES.bgBlackBright!]),
+	});
+	Object.defineProperty(builder, "bgGrey", {
+		get: () => createBuilder(context, [...styles, STYLES.bgBlackBright!]),
+	});
+	Object.defineProperty(builder, "hex", {
+		value: (color: string) => createBuilder(context, [...styles, hexStyle(color, context.level)]),
+	});
+	return builder;
+}
+
+function ChalkImplementation(this: unknown, options: ChalkOptions = {}): ChalkInstance {
+	const detectedLevel = supportsColor === false ? 0 : supportsColor.level;
+	return createBuilder({ level: options.level ?? detectedLevel }, []);
+}
+
+/** Construct an independently configured chalk formatter. */
+export const Chalk = ChalkImplementation as unknown as ChalkConstructor;
+
+const defaultLevel = supportsColor === false ? 0 : supportsColor.level;
+const chalk = new Chalk({ level: defaultLevel });
+
+export default chalk;

package/src/dates.ts

@@ -0,0 +1,194 @@
+/** Behavior-compatible reimplementation of date-fns's used surface. */
+
+const MONTHS = [
+	"January",
+	"February",
+	"March",
+	"April",
+	"May",
+	"June",
+	"July",
+	"August",
+	"September",
+	"October",
+	"November",
+	"December",
+] as const;
+const WEEKDAYS = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] as const;
+const TOKENS = [
+	"MMMM",
+	"yyyy",
+	"EEEE",
+	"MMM",
+	"EEE",
+	"yy",
+	"MM",
+	"dd",
+	"HH",
+	"hh",
+	"mm",
+	"ss",
+	"M",
+	"d",
+	"H",
+	"h",
+	"m",
+	"s",
+	"a",
+] as const;
+
+function pad(value: number, length = 2): string {
+	return String(value).padStart(length, "0");
+}
+
+function tokenValue(date: Date, token: (typeof TOKENS)[number]): string {
+	const month = date.getMonth();
+	const weekday = date.getDay();
+	const hours = date.getHours();
+	const hours12 = hours % 12 || 12;
+
+	switch (token) {
+		case "yyyy":
+			return pad(date.getFullYear(), 4);
+		case "yy":
+			return pad(date.getFullYear() % 100);
+		case "MMMM":
+			return MONTHS[month];
+		case "MMM":
+			return MONTHS[month].slice(0, 3);
+		case "MM":
+			return pad(month + 1);
+		case "M":
+			return String(month + 1);
+		case "dd":
+			return pad(date.getDate());
+		case "d":
+			return String(date.getDate());
+		case "EEEE":
+			return WEEKDAYS[weekday];
+		case "EEE":
+			return WEEKDAYS[weekday].slice(0, 3);
+		case "HH":
+			return pad(hours);
+		case "H":
+			return String(hours);
+		case "hh":
+			return pad(hours12);
+		case "h":
+			return String(hours12);
+		case "mm":
+			return pad(date.getMinutes());
+		case "m":
+			return String(date.getMinutes());
+		case "ss":
+			return pad(date.getSeconds());
+		case "s":
+			return String(date.getSeconds());
+		case "a":
+			return hours < 12 ? "AM" : "PM";
+	}
+}
+
+function asDate(value: Date | number): Date {
+	const date = value instanceof Date ? new Date(value.getTime()) : new Date(value);
+	if (Number.isNaN(date.getTime())) throw new RangeError("Invalid time value");
+	return date;
+}
+
+/** Format a date with the supported date-fns v4 tokens and quoted literals. */
+export function format(value: Date | number, pattern: string): string {
+	const date = asDate(value);
+	let result = "";
+
+	for (let index = 0; index < pattern.length; ) {
+		if (pattern[index] === "'") {
+			if (pattern[index + 1] === "'") {
+				result += "'";
+				index += 2;
+				continue;
+			}
+
+			index++;
+			while (index < pattern.length) {
+				if (pattern[index] !== "'") {
+					result += pattern[index++];
+					continue;
+				}
+				if (pattern[index + 1] === "'") {
+					result += "'";
+					index += 2;
+					continue;
+				}
+				index++;
+				break;
+			}
+			continue;
+		}
+
+		const rest = pattern.slice(index);
+		const token = TOKENS.find(candidate => rest.startsWith(candidate));
+		if (token) {
+			result += tokenValue(date, token);
+			index += token.length;
+			continue;
+		}
+
+		const character = pattern[index++];
+		if (/[A-Za-z]/.test(character)) {
+			throw new RangeError(`Format string contains an unescaped latin alphabet character \`${character}\``);
+		}
+		result += character;
+	}
+
+	return result;
+}
+
+function plural(count: number, singular: string): string {
+	return `${count} ${count === 1 ? singular : `${singular}s`}`;
+}
+
+function completedMonths(earlier: Date, later: Date): number {
+	let months = (later.getFullYear() - earlier.getFullYear()) * 12 + later.getMonth() - earlier.getMonth();
+	if (months === 0) return 0;
+
+	const candidate = new Date(earlier);
+	candidate.setDate(1);
+	candidate.setFullYear(earlier.getFullYear(), earlier.getMonth() + months, 1);
+	const lastDay = new Date(candidate.getFullYear(), candidate.getMonth() + 1, 0).getDate();
+	candidate.setDate(Math.min(earlier.getDate(), lastDay));
+	if (candidate.getTime() > later.getTime()) months--;
+	return months;
+}
+
+function distanceWords(earlier: Date, later: Date): string {
+	const seconds = (later.getTime() - earlier.getTime()) / 1_000;
+	const timezoneOffset = (later.getTimezoneOffset() - earlier.getTimezoneOffset()) * 60;
+	const minutes = Math.round((seconds - timezoneOffset) / 60);
+
+	if (minutes < 2) return minutes === 0 ? "less than a minute" : "1 minute";
+	if (minutes < 45) return plural(minutes, "minute");
+	if (minutes < 90) return "about 1 hour";
+	if (minutes < 1_440) return `about ${plural(Math.round(minutes / 60), "hour")}`;
+	if (minutes < 2_520) return "1 day";
+	if (minutes < 43_200) return plural(Math.round(minutes / 1_440), "day");
+	if (minutes < 86_400) return `about ${plural(Math.round(minutes / 43_200), "month")}`;
+
+	const months = completedMonths(earlier, later);
+	if (months < 12) return plural(Math.round(minutes / 43_200), "month");
+
+	const years = Math.trunc(months / 12);
+	const remainingMonths = months % 12;
+	if (remainingMonths < 3) return `about ${plural(years, "year")}`;
+	if (remainingMonths < 9) return `over ${plural(years, "year")}`;
+	return `almost ${plural(years + 1, "year")}`;
+}
+
+/** Describe the distance from a date to now using date-fns's English thresholds. */
+export function formatDistanceToNow(value: Date | number, options: { addSuffix?: boolean } = {}): string {
+	const date = asDate(value);
+	const now = new Date(Date.now());
+	const isFuture = date.getTime() > now.getTime();
+	const words = isFuture ? distanceWords(now, date) : distanceWords(date, now);
+	if (!options.addSuffix) return words;
+	return isFuture ? `in ${words}` : `${words} ago`;
+}