Diffusion Ant (type-hints-typescript) Code

ant/examples/spec/readline.js
899dad6b8a9etype-hints-typescript

readline.js
View Options

			import { test, testDeep, summary } from './helpers.js';
			import * as readline from 'node:readline';
			import * as readlinePromises from 'node:readline/promises';

			console.log('Readline Tests\n');

			test('readline has createInterface', typeof readline.createInterface, 'function');
			test('readline has clearLine', typeof readline.clearLine, 'function');
			test('readline has clearScreenDown', typeof readline.clearScreenDown, 'function');
			test('readline has cursorTo', typeof readline.cursorTo, 'function');
			test('readline has moveCursor', typeof readline.moveCursor, 'function');
			test('readline has emitKeypressEvents', typeof readline.emitKeypressEvents, 'function');

			test('readline/promises has createInterface', typeof readlinePromises.createInterface, 'function');

			const rl = readline.createInterface({
			input: process.stdin,
			output: process.stdout,
			prompt: 'test> ',
			historySize: 50,
			removeHistoryDuplicates: true,
			tabSize: 4
			});

			test('interface is object', typeof rl, 'object');
			test('interface has on method', typeof rl.on, 'function');
			test('interface has once method', typeof rl.once, 'function');
			test('interface has off method', typeof rl.off, 'function');
			test('interface has emit method', typeof rl.emit, 'function');
			test('interface has close method', typeof rl.close, 'function');
			test('interface has pause method', typeof rl.pause, 'function');
			test('interface has resume method', typeof rl.resume, 'function');
			test('interface has prompt method', typeof rl.prompt, 'function');
			test('interface has setPrompt method', typeof rl.setPrompt, 'function');
			test('interface has getPrompt method', typeof rl.getPrompt, 'function');
			test('interface has write method', typeof rl.write, 'function');
			test('interface has question method', typeof rl.question, 'function');
			test('interface has getCursorPos method', typeof rl.getCursorPos, 'function');

			test('line property is string', typeof rl.line, 'string');
			test('line property initially empty', rl.line, '');

			test('cursor property is number', typeof rl.cursor, 'number');
			test('cursor property initially 0', rl.cursor, 0);

			test('closed property is boolean', typeof rl.closed, 'boolean');
			test('closed property initially false', rl.closed, false);

			const cursorPos = rl.getCursorPos();
			test('getCursorPos returns object', typeof cursorPos, 'object');
			test('getCursorPos has rows', typeof cursorPos.rows, 'number');
			test('getCursorPos has cols', typeof cursorPos.cols, 'number');

			test('getPrompt returns initial prompt', rl.getPrompt(), 'test> ');

			rl.setPrompt('new> ');
			test('setPrompt updates prompt', rl.getPrompt(), 'new> ');

			test('terminal property exists', typeof rl.terminal, 'boolean');
			test('has Symbol.asyncIterator', typeof rl[Symbol.asyncIterator], 'function');

			let closeEventFired = false;
			rl.on('close', () => {
			closeEventFired = true;
			});

			let pauseEventFired = false;
			rl.on('pause', () => {
			pauseEventFired = true;
			});

			let resumeEventFired = false;
			rl.on('resume', () => {
			resumeEventFired = true;
			});

			rl.pause();
			test('pause event fired', pauseEventFired, true);

			rl.resume();
			test('resume event fired', resumeEventFired, true);

			rl.close();
			test('close event fired', closeEventFired, true);
			test('closed property true after close', rl.closed, true);

			const clearLineResult = readline.clearLine(process.stdout, 0);
			test('clearLine returns boolean', typeof clearLineResult, 'boolean');

			const cursorToResult = readline.cursorTo(process.stdout, 0);
			test('cursorTo returns boolean', typeof cursorToResult, 'boolean');

			const moveCursorResult = readline.moveCursor(process.stdout, 0, 0);
			test('moveCursor returns boolean', typeof moveCursorResult, 'boolean');

			const rlPromises = readlinePromises.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			test('promises interface is object', typeof rlPromises, 'object');
			test('promises interface has question', typeof rlPromises.question, 'function');
			rlPromises.close();

			const rlDefault = readline.createInterface({
			input: process.stdin,
			output: process.stdout
			});
			test('default prompt is "> "', rlDefault.getPrompt(), '> ');
			rlDefault.close();

			const rlHistory = readline.createInterface({
			input: process.stdin,
			output: process.stdout,
			history: ['cmd1', 'cmd2', 'cmd3']
			});
			test('history interface created', typeof rlHistory, 'object');
			rlHistory.close();

			const rl2 = readline.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			test('addListener is function', typeof rl2.addListener, 'function');
			test('removeListener is function', typeof rl2.removeListener, 'function');

			let testEventFired = false;
			const testHandler = () => {
			testEventFired = true;
			};
			rl2.addListener('test', testHandler);
			rl2.emit('test');
			test('addListener works', testEventFired, true);

			testEventFired = false;
			rl2.removeListener('test', testHandler);
			rl2.emit('test');
			test('removeListener works', testEventFired, false);

			rl2.close();

			const rl3 = readline.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			let onceCount = 0;
			rl3.once('myevent', () => {
			onceCount++;
			});
			rl3.emit('myevent');
			rl3.emit('myevent');
			test('once only fires once', onceCount, 1);
			rl3.close();

			const rl4 = readline.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			const chainResult = rl4.on('test', () => {});
			test('on returns interface for chaining', chainResult, rl4);
			rl4.close();

			const rl5 = readline.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			rl5.write('hello');
			test('write updates line', rl5.line, 'hello');
			test('write updates cursor', rl5.cursor, 5);

			rl5.write(null, { name: 'backspace' });
			test('backspace key works', rl5.line, 'hell');
			test('backspace updates cursor', rl5.cursor, 4);

			rl5.write(null, { name: 'left' });
			test('left arrow updates cursor', rl5.cursor, 3);

			rl5.write(null, { name: 'right' });
			test('right arrow updates cursor', rl5.cursor, 4);

			rl5.write(null, { name: 'home' });
			test('home key moves cursor to 0', rl5.cursor, 0);

			rl5.write(null, { name: 'end' });
			test('end key moves cursor to end', rl5.cursor, 4);

			rl5.write(null, { name: 'u', ctrl: true });
			test('ctrl+u clears line', rl5.line, '');

			rl5.close();

			const rlAsync = readlinePromises.createInterface({
			input: process.stdin,
			output: process.stdout
			});

			const asyncLines = [];
			const consumeAsyncLines = (async () => {
			for await (const line of rlAsync) {
			asyncLines.push(line);
			if (asyncLines.length === 2) break;
			}
			})();

			rlAsync.write('alpha\n');
			rlAsync.write('beta\n');
			await consumeAsyncLines;

			testDeep('async iterator yields lines', asyncLines, ['alpha', 'beta']);
			test('async iterator closes interface after break', rlAsync.closed, true);

			summary();

Owner Packages

No Owners