@oh-my-pi/pi-utils 17.2.8 → 17.2.10

package/src/version.ts

@@ -0,0 +1,99 @@
+const DIGITS = /^\d+$/;
+
+/**
+ * Compare two version strings.
+ *
+ * Canonical comparator that supersedes the historical in-repo copies
+ * (update-cli, hackage scraper, release scripts):
+ * - inputs are trimmed and at most one leading `v`/`V` is stripped
+ * - dot-separated segments are compared numerically, missing trailing
+ *   segments count as 0, so `1.2` === `1.2.0` and any segment count works
+ * - a SemVer-2.0 prerelease suffix sorts before the plain release
+ *   (`1.0.0-beta` < `1.0.0`); prerelease identifiers follow SemVer order
+ *   (numeric < alphanumeric, numeric compared by value, alphanumeric
+ *   compared lexically, longer sets of equal fields win)
+ * - SemVer build metadata begins at the first `+` and does not participate
+ *   in precedence; it is stripped before core/prerelease parsing
+ * - malformed numeric segments compare as 0 (`1.2.x` === `1.2.0`)
+ * - never throws; returns only -1 | 0 | 1
+ */
+export function compareVersions(a: string, b: string): number {
+	const pa = parseVersion(a);
+	const pb = parseVersion(b);
+
+	const core = compareNumericParts(pa.core, pb.core);
+	if (core !== 0) return core;
+
+	return comparePrerelease(pa.prerelease, pb.prerelease);
+}
+
+interface ParsedVersion {
+	core: string[];
+	prerelease: string[] | null;
+}
+
+function parseVersion(version: string): ParsedVersion {
+	const trimmed = version.trim();
+	const stripped = trimmed.startsWith("v") || trimmed.startsWith("V") ? trimmed.slice(1) : trimmed;
+	const plusIndex = stripped.indexOf("+");
+	const withoutBuild = plusIndex === -1 ? stripped : stripped.slice(0, plusIndex);
+	const dashIndex = withoutBuild.indexOf("-");
+	if (dashIndex === -1) {
+		return { core: withoutBuild.split("."), prerelease: null };
+	}
+	return {
+		core: withoutBuild.slice(0, dashIndex).split("."),
+		prerelease: withoutBuild.slice(dashIndex + 1).split("."),
+	};
+}
+
+/** Compare dot-separated numeric segments; missing/malformed segments count as 0. */
+function compareNumericParts(a: string[], b: string[]): number {
+	const length = Math.max(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		// Missing or malformed segments compare as 0.
+		const sa = a[i];
+		const sb = b[i];
+		const result = compareDigits(
+			sa !== undefined && DIGITS.test(sa) ? sa : "0",
+			sb !== undefined && DIGITS.test(sb) ? sb : "0",
+		);
+		if (result !== 0) return result;
+	}
+	return 0;
+}
+
+/** Exact integer comparison of digit strings, avoiding float overflow. */
+function compareDigits(a: string, b: string): number {
+	const na = a.replace(/^0+/, "") || "0";
+	const nb = b.replace(/^0+/, "") || "0";
+	if (na.length !== nb.length) return na.length < nb.length ? -1 : 1;
+	if (na < nb) return -1;
+	if (na > nb) return 1;
+	return 0;
+}
+
+/** SemVer-2.0 prerelease ordering; null means a plain release, which wins. */
+function comparePrerelease(a: string[] | null, b: string[] | null): number {
+	if (a === null || b === null) {
+		return a === b ? 0 : a === null ? 1 : -1;
+	}
+	const length = Math.max(a.length, b.length);
+	for (let i = 0; i < length; i++) {
+		const ia = a[i];
+		const ib = b[i];
+		if (ia === undefined) return -1;
+		if (ib === undefined) return 1;
+		const aNumeric = DIGITS.test(ia);
+		const bNumeric = DIGITS.test(ib);
+		if (aNumeric && bNumeric) {
+			const result = compareDigits(ia, ib);
+			if (result !== 0) return result;
+		} else if (aNumeric !== bNumeric) {
+			return aNumeric ? -1 : 1;
+		} else if (ia !== ib) {
+			return ia < ib ? -1 : 1;
+		}
+	}
+	return 0;
+}

package/src/vterm/buffer.ts

@@ -0,0 +1,218 @@
+/** Cell rendition tracked by the virtual terminal. */
+export interface CellAttributes {
+	bold: boolean;
+	dim: boolean;
+	italic: boolean;
+	underline: boolean;
+	inverse: boolean;
+	strikethrough: boolean;
+	overline: boolean;
+	fgMode: 0 | 1 | 2;
+	fg: number;
+	bgMode: 0 | 1 | 2;
+	bg: number;
+}
+
+/** A mutable terminal grid cell. */
+export interface CellData {
+	chars: string;
+	width: number;
+	attrs: CellAttributes;
+}
+
+/** Creates the default rendition. */
+export function defaultAttributes(): CellAttributes {
+	return {
+		bold: false,
+		dim: false,
+		italic: false,
+		underline: false,
+		inverse: false,
+		strikethrough: false,
+		overline: false,
+		fgMode: 0,
+		fg: 0,
+		bgMode: 0,
+		bg: 0,
+	};
+}
+
+function cloneAttributes(attrs: CellAttributes): CellAttributes {
+	return { ...attrs };
+}
+
+/** Creates an empty cell with the supplied rendition. */
+export function blankCell(attrs: CellAttributes = defaultAttributes()): CellData {
+	return { chars: "", width: 1, attrs: cloneAttributes(attrs) };
+}
+
+/** Proposed xterm-compatible cell readback object. */
+export class BufferCell {
+	#cell: CellData = blankCell();
+
+	/** Reuses this object for another grid cell. */
+	setFrom(cell: CellData): this {
+		this.#cell = cell;
+		return this;
+	}
+
+	/** Returns the grapheme stored in this cell. */
+	getChars(): string {
+		return this.#cell.chars;
+	}
+
+	/** Returns the cell width, with zero denoting a wide-cell continuation. */
+	getWidth(): number {
+		return this.#cell.width;
+	}
+
+	/** Returns the packed foreground palette index or RGB value. */
+	getFgColor(): number {
+		return this.#cell.attrs.fg;
+	}
+
+	/** Returns the packed background palette index or RGB value. */
+	getBgColor(): number {
+		return this.#cell.attrs.bg;
+	}
+
+	/** Reports bold rendition. */
+	isBold(): number {
+		return Number(this.#cell.attrs.bold);
+	}
+
+	/** Reports dim rendition. */
+	isDim(): number {
+		return Number(this.#cell.attrs.dim);
+	}
+
+	/** Reports italic rendition. */
+	isItalic(): number {
+		return Number(this.#cell.attrs.italic);
+	}
+
+	/** Reports underline rendition. */
+	isUnderline(): number {
+		return Number(this.#cell.attrs.underline);
+	}
+
+	/** Reports inverse rendition. */
+	isInverse(): number {
+		return Number(this.#cell.attrs.inverse);
+	}
+
+	/** Reports strikethrough rendition. */
+	isStrikethrough(): number {
+		return Number(this.#cell.attrs.strikethrough);
+	}
+
+	/** Reports overline rendition. */
+	isOverline(): number {
+		return Number(this.#cell.attrs.overline);
+	}
+
+	/** Reports a true-color foreground. */
+	isFgRGB(): boolean {
+		return this.#cell.attrs.fgMode === 2;
+	}
+
+	/** Reports a true-color background. */
+	isBgRGB(): boolean {
+		return this.#cell.attrs.bgMode === 2;
+	}
+
+	/** Reports a palette foreground. */
+	isFgPalette(): boolean {
+		return this.#cell.attrs.fgMode === 1;
+	}
+
+	/** Reports a palette background. */
+	isBgPalette(): boolean {
+		return this.#cell.attrs.bgMode === 1;
+	}
+}
+
+/** One physical row in a terminal buffer. */
+export class BufferLine {
+	cells: CellData[];
+	isWrapped = false;
+
+	constructor(columns: number, attrs: CellAttributes = defaultAttributes()) {
+		this.cells = Array.from({ length: columns }, () => blankCell(attrs));
+	}
+
+	/** Number of grid columns in the line. */
+	get length(): number {
+		return this.cells.length;
+	}
+
+	/** Reads a cell, optionally reusing the caller's object. */
+	getCell(column: number, cell = new BufferCell()): BufferCell | undefined {
+		const value = this.cells[column];
+		return value ? cell.setFrom(value) : undefined;
+	}
+
+	/** Converts a column range to text. */
+	translateToString(trimRight = false, startColumn = 0, endColumn = this.cells.length): string {
+		const start = Math.max(0, startColumn);
+		let end = Math.min(endColumn, this.cells.length);
+		if (trimRight) {
+			while (end > start && !this.cells[end - 1]!.chars) end--;
+		}
+		let text = "";
+		for (let column = start; column < end; column++) {
+			const cell = this.cells[column]!;
+			if (cell.width !== 0) text += cell.chars || " ";
+		}
+		return text;
+	}
+}
+
+/** Storage backing one terminal screen and its history. */
+export interface BufferState {
+	lines: BufferLine[];
+	baseY: number;
+	viewportY: number;
+	cursorX: number;
+	cursorY: number;
+}
+
+/** Public xterm-compatible view over a buffer state. */
+export class BufferView {
+	constructor(private readonly state: () => BufferState) {}
+
+	/** Number of physical lines, including scrollback. */
+	get length(): number {
+		return this.state().lines.length;
+	}
+
+	/** First row of the live screen in the full buffer. */
+	get baseY(): number {
+		return this.state().baseY;
+	}
+
+	/** First row currently exposed by the viewport. */
+	get viewportY(): number {
+		return this.state().viewportY;
+	}
+
+	/** Cursor column in the live screen. */
+	get cursorX(): number {
+		return this.state().cursorX;
+	}
+
+	/** Cursor row in the live screen. */
+	get cursorY(): number {
+		return this.state().cursorY;
+	}
+
+	/** Reads a physical buffer line. */
+	getLine(row: number): BufferLine | undefined {
+		return this.state().lines[row];
+	}
+
+	/** Creates a reusable empty cell readback object. */
+	getNullCell(): BufferCell {
+		return new BufferCell();
+	}
+}