Minor refactoring, add some more comments and tests

src/bun/mod.ts

@@ -6,6 +6,8 @@ import { IRuntime, RunTimeType } from '../common/runtime.ts';
 import BunTerminalIO from './terminal_io.ts';
 import BunFileIO from './file_io.ts';
 
+import * as process from 'node:process';
+
 const BunRuntime: IRuntime = {
 	name: RunTimeType.Bun,
 	file: BunFileIO,

src/common/all_test.ts

@@ -1,12 +1,13 @@
+import Ansi, * as _Ansi from './ansi.ts';
 import Buffer from './buffer.ts';
 import Document from './document.ts';
 import Editor from './editor.ts';
+import Position from './position.ts';
 import Row from './row.ts';
-import { Ansi, KeyCommand } from './ansi.ts';
+
+import * as Fn from './fns.ts';
 import { defaultTerminalSize, SCROLL_TAB_SIZE } from './config.ts';
 import { getTestRunner } from './runtime.ts';
-import { Position } from './types.ts';
-import * as Fn from './fns.ts';
 
 const {
 	assertEquals,
@@ -19,7 +20,23 @@ const {
 	testSuite,
 } = await getTestRunner();
 
-const ANSITest = {
+// ----------------------------------------------------------------------------
+
+const ANSITest = () => {
+	const { AnsiColor, Ground } = _Ansi;
+
+	return {
+		'color()': () => {
+			assertEquals(Ansi.color(AnsiColor.FgBlue), '\x1b[34m');
+		},
+		'color256()': () => {
+			assertEquals(Ansi.color256(128, Ground.Back), '\x1b[48;5;128m');
+			assertEquals(Ansi.color256(128, Ground.Fore), '\x1b[38;5;128m');
+		},
+		'rgb()': () => {
+			assertEquals(Ansi.rgb(32, 64, 128, Ground.Back), '\x1b[48;2;32;64;128m');
+			assertEquals(Ansi.rgb(32, 64, 128, Ground.Fore), '\x1b[38;2;32;64;128m');
+		},
 		'moveCursor()': () => {
 			assertEquals(Ansi.moveCursor(1, 2), '\x1b[2;3H');
 		},
@@ -29,6 +46,7 @@ const ANSITest = {
 		'moveCursorDown()': () => {
 			assertEquals(Ansi.moveCursorDown(7), '\x1b[7B');
 		},
+	};
 };
 
 // ----------------------------------------------------------------------------
@@ -244,27 +262,41 @@ const RowTest = {
 
 // ----------------------------------------------------------------------------
 
-const fnTest = {
-	'defined()': () => {
-		const { defined } = Fn;
-		assertFalse(defined(null));
-		assertFalse(defined(void 0));
-		assertFalse(defined(undefined));
-		assertTrue(defined(0));
-		assertTrue(defined(false));
-	},
-	'nullish()': () => {
-		const { nullish } = Fn;
+const fnTest = () => {
+	const {
+		some,
+		none,
+		arrayInsert,
+		noop,
+		posSub,
+		minSub,
+		maxAdd,
+		ord,
+		strChars,
+		ctrlKey,
+		isControl,
+		isAscii,
+		isAsciiDigit,
+		strlen,
+		truncate,
+	} = Fn;
 
-		assertTrue(nullish(null));
-		assertTrue(nullish(void 0));
-		assertTrue(nullish(undefined));
-		assertFalse(nullish(0));
-		assertFalse(nullish(false));
+	return {
+		'some()': () => {
+			assertFalse(some(null));
+			assertFalse(some(void 0));
+			assertFalse(some(undefined));
+			assertTrue(some(0));
+			assertTrue(some(false));
+		},
+		'none()': () => {
+			assertTrue(none(null));
+			assertTrue(none(void 0));
+			assertTrue(none(undefined));
+			assertFalse(none(0));
+			assertFalse(none(false));
 		},
 		'arrayInsert() strings': () => {
-		const { arrayInsert } = Fn;
-
 			const a = ['😺', '😸', '😹'];
 			const b = arrayInsert(a, 1, 'x');
 			const c = ['😺', 'x', '😸', '😹'];
@@ -277,8 +309,6 @@ const fnTest = {
 			assertEquals(arrayInsert([], 0, 'foo'), ['foo']);
 		},
 		'arrayInsert() numbers': () => {
-		const { arrayInsert } = Fn;
-
 			const a = [1, 3, 5];
 			const b = [1, 3, 4, 5];
 			assertEquals(arrayInsert(a, 2, 4), b);
@@ -287,24 +317,22 @@ const fnTest = {
 			assertEquals(arrayInsert(b, 1, 2), c);
 		},
 		'noop fn': () => {
-		assertExists(Fn.noop);
-		assertEquals(Fn.noop(), undefined);
+			assertExists(noop);
+			assertEquals(noop(), undefined);
 		},
 		'posSub()': () => {
-		assertEquals(Fn.posSub(14, 15), 0);
-		assertEquals(Fn.posSub(15, 1), 14);
+			assertEquals(posSub(14, 15), 0);
+			assertEquals(posSub(15, 1), 14);
 		},
 		'minSub()': () => {
-		assertEquals(Fn.minSub(13, 25, -1), -1);
-		assertEquals(Fn.minSub(25, 13, 0), 12);
+			assertEquals(minSub(13, 25, -1), -1);
+			assertEquals(minSub(25, 13, 0), 12);
 		},
 		'maxAdd()': () => {
-		assertEquals(Fn.maxAdd(99, 99, 75), 75);
-		assertEquals(Fn.maxAdd(25, 74, 101), 99);
+			assertEquals(maxAdd(99, 99, 75), 75);
+			assertEquals(maxAdd(25, 74, 101), 99);
 		},
 		'ord()': () => {
-		const { ord } = Fn;
-
 			// Invalid output
 			assertEquals(ord(''), 256);
 
@@ -312,13 +340,9 @@ const fnTest = {
 			assertEquals(ord('a'), 97);
 		},
 		'strChars() properly splits strings into unicode characters': () => {
-		const { strChars } = Fn;
-
 			assertEquals(strChars('😺😸😹'), ['😺', '😸', '😹']);
 		},
 		'ctrlKey()': () => {
-		const { ctrlKey, isControl } = Fn;
-
 			const ctrl_a = ctrlKey('a');
 			assertTrue(isControl(ctrl_a));
 			assertEquals(ctrl_a, String.fromCodePoint(0x01));
@@ -328,30 +352,22 @@ const fnTest = {
 			assertEquals(invalid, '😺');
 		},
 		'isAscii()': () => {
-		const { isAscii } = Fn;
-
 			assertTrue(isAscii('asjyverkjhsdf1928374'));
 			assertFalse(isAscii('😺acalskjsdf'));
 			assertFalse(isAscii('ab😺ac'));
 		},
 		'isAsciiDigit()': () => {
-		const { isAsciiDigit } = Fn;
-
 			assertTrue(isAsciiDigit('1234567890'));
 			assertFalse(isAsciiDigit('A1'));
 			assertFalse(isAsciiDigit('/'));
 			assertFalse(isAsciiDigit(':'));
 		},
 		'isControl()': () => {
-		const { isControl } = Fn;
-
 			assertFalse(isControl('abc'));
 			assertTrue(isControl(String.fromCodePoint(0x01)));
 			assertFalse(isControl('😺'));
 		},
 		'strlen()': () => {
-		const { strlen } = Fn;
-
 			// Ascii length
 			assertEquals(strlen('abc'), 'abc'.length);
 
@@ -368,54 +384,57 @@ const fnTest = {
 			assertNotEquals('👨‍👩‍👧‍👦'.length, strlen('👨‍👩‍👧‍👦'));
 		},
 		'truncate()': () => {
-		const { truncate } = Fn;
-
 			assertEquals(truncate('😺😸😹', 1), '😺');
 			assertEquals(truncate('😺😸😹', 5), '😺😸😹');
 			assertEquals(truncate('👨‍👩‍👧‍👦', 5), '👨‍👩‍👧');
 		},
+	};
 };
 
 // ----------------------------------------------------------------------------
 
-const encoder = new TextEncoder();
+const readKeyTest = () => {
+	const { KeyCommand } = _Ansi;
+	const { readKey, ctrlKey } = Fn;
 
-const testKeyMap = (codes: string[], expected: string) => {
+	const encoder = new TextEncoder();
+
+	const testKeyMap = (codes: string[], expected: string) => {
 		codes.forEach((code) => {
-		assertEquals(Fn.readKey(encoder.encode(code)), expected);
+			assertEquals(readKey(encoder.encode(code)), expected);
 		});
-};
+	};
 
-const readKeyTest = {
+	return {
 		'empty input': () => {
-		assertEquals(Fn.readKey(new Uint8Array(0)), '');
+			assertEquals(readKey(new Uint8Array(0)), '');
 		},
 		'passthrough': () => {
 			// Ignore unhandled escape sequences
-		assertEquals(Fn.readKey(encoder.encode('\x1b[]')), '\x1b[]');
+			assertEquals(readKey(encoder.encode('\x1b[]')), '\x1b[]');
 
 			// Pass explicitly mapped values right through
 			assertEquals(
-			Fn.readKey(encoder.encode(KeyCommand.ArrowUp)),
+				readKey(encoder.encode(KeyCommand.ArrowUp)),
 				KeyCommand.ArrowUp,
 			);
 			assertEquals(
-			Fn.readKey(encoder.encode(KeyCommand.Home)),
+				readKey(encoder.encode(KeyCommand.Home)),
 				KeyCommand.Home,
 			);
 			assertEquals(
-			Fn.readKey(encoder.encode(KeyCommand.Delete)),
+				readKey(encoder.encode(KeyCommand.Delete)),
 				KeyCommand.Delete,
 			);
 
 			// And pass through whatever else
-		assertEquals(Fn.readKey(encoder.encode('foobaz')), 'foobaz');
+			assertEquals(readKey(encoder.encode('foobaz')), 'foobaz');
 		},
 
-	'Esc': () => testKeyMap(['\x1b', Fn.ctrlKey('l')], KeyCommand.Escape),
+		'Esc': () => testKeyMap(['\x1b', ctrlKey('l')], KeyCommand.Escape),
 		'Backspace': () =>
 			testKeyMap(
-			[Fn.ctrlKey('h'), '\x7f'],
+				[ctrlKey('h'), '\x7f'],
 				KeyCommand.Backspace,
 			),
 		'Home': () =>
@@ -423,6 +442,7 @@ const readKeyTest = {
 		'End': () =>
 			testKeyMap(['\x1b[4~', '\x1b[8~', '\x1b[F', '\x1bOF'], KeyCommand.End),
 		'Enter': () => testKeyMap(['\n', '\r', '\v'], KeyCommand.Enter),
+	};
 };
 
 // ----------------------------------------------------------------------------
@@ -430,12 +450,12 @@ const readKeyTest = {
 // ----------------------------------------------------------------------------
 
 testSuite({
-	'ANSI utils': ANSITest,
+	'ANSI utils': ANSITest(),
 	Buffer: BufferTest,
 	Document: DocumentTest,
 	Editor: EditorTest,
 	Position: PositionTest,
 	Row: RowTest,
-	fns: fnTest,
-	'readKey()': readKeyTest,
+	fns: fnTest(),
+	'readKey()': readKeyTest(),
 });

src/common/document.ts

@@ -1,5 +1,5 @@
 import Row from './row.ts';
-import { arrayInsert, strlen } from './fns.ts';
+import { arrayInsert, some, strlen } from './fns.ts';
 import { HighlightType } from './highlight.ts';
 import { getRuntime } from './runtime.ts';
 import { Position } from './types.ts';
@@ -76,7 +76,7 @@ export class Document {
 		key: string,
 	): Position | null {
 		const potential = this.#search.search(q, key);
-		if (potential !== null) {
+		if (some(potential) && potential instanceof Position) {
 			// Update highlight of search match
 			const row = this.#rows[potential.y];
 

src/common/editor.ts

@@ -8,8 +8,10 @@ import {
 	ctrlKey,
 	isControl,
 	maxAdd,
+	none,
 	posSub,
 	readKey,
+	some,
 	truncate,
 } from './fns.ts';
 import { getRuntime, log, LogLevel } from './runtime.ts';
@@ -254,7 +256,7 @@ class Editor {
 			await this.refreshScreen();
 			for await (const chunk of term.inputLoop()) {
 				const char = readKey(chunk);
-				if (char === null) {
+				if (none(char)) {
 					continue;
 				}
 
@@ -312,7 +314,7 @@ class Editor {
 					return null;
 				}
 
-				if (query !== null && query.length > 0) {
+				if (some(query) && query.length > 0) {
 					const pos = this.#document.find(query, key);
 					if (pos !== null) {
 						// We have a match here

src/common/fns.ts

@@ -14,14 +14,14 @@ export const noop = () => {};
 /**
  * Does a value exist? (not null or undefined)
  */
-export function defined(v: unknown): boolean {
+export function some(v: unknown): boolean {
 	return v !== null && typeof v !== 'undefined';
 }
 
 /**
  * Is the value null or undefined?
  */
-export function nullish(v: unknown): boolean {
+export function none(v: unknown): boolean {
 	return v === null || typeof v === 'undefined';
 }
 

src/common/position.ts

@@ -16,3 +16,5 @@ export class Position {
 		return new Position();
 	}
 }
+
+export default Position;

src/common/row.ts

@@ -1,5 +1,5 @@
 import { SCROLL_TAB_SIZE } from './config.ts';
-import { arrayInsert, isAsciiDigit, strChars } from './fns.ts';
+import { arrayInsert, isAsciiDigit, some, strChars } from './fns.ts';
 import { highlightToColor, HighlightType } from './highlight.ts';
 import Ansi from './ansi.ts';
 
@@ -68,6 +68,9 @@ export class Row {
 		}
 	}
 
+	/**
+	 * Truncate the current row, and return a new one at the specified index
+	 */
 	public split(at: number): Row {
 		const newRow = new Row(this.chars.slice(at));
 		this.chars = this.chars.slice(0, at);
@@ -76,6 +79,9 @@ export class Row {
 		return newRow;
 	}
 
+	/**
+	 * Remove a character at the specified index
+	 */
 	public delete(at: number): void {
 		if (at >= this.size) {
 			return;

src/common/runtime.ts

@@ -85,10 +85,13 @@ export async function getRuntime(): Promise<IRuntime> {
 		const pkg = await import(path);
 		if ('default' in pkg) {
 			scrollRuntime = pkg.default;
+			if (scrollRuntime !== null) {
+				return Promise.resolve(scrollRuntime);
+			}
 		}
 	}
 
-	return Promise.resolve(scrollRuntime!);
+	return Promise.reject('Missing default import');
 }
 
 /**