@hankchanocd/npmlist/build/npmRegistry.js

/**
 * npmRegistry.js fetches package dependencies and others infos from npm registry
 * It uses chain operations that are divided into 2 categories: simple() and all()
 *
 */
'use strict';

// Dependencies

function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }

const chalk = require('chalk');
const ui = require('cliui')();
const columnify = require('columnify');
const iPipeTo = require('ipt');
const {
	fetch
} = require('./utils/promiseUtil');
const {
	spawn
} = require('child_process');
const StringUtil = require('./utils/stringUtil');

/*
 * npmRegistry has only one exposed export function.
 * It has two dimensions of two options for output: simple() and all(), default() and fuzzy().
 * Chain operations are flexible for future expansion with backward compatibility
 *
 */
module.exports.main = (() => {
	var _ref = _asyncToGenerator(function* (module = '') {
		if (!module) {
			throw chalk.redBright('No module provided');
		}

		let data;
		try {
			data = JSON.parse((yield fetch(`https://registry.npmjs.org/${module}`)));
		} catch (err) {
			console.log(chalk.redBright(err));
		}

		// First-level chain operation has simple() and all()
		return {
			simple() {
				let list = parseToList(data).simple();

				// Second-level chain operation has default(), fuzzy(), raw(), rawNoColor()
				return {
					default() {
						if (!list || list.length === 0) return;

						return list.forEach(i => console.log(i));
					},
					fuzzy() {
						if (!list || list.length === 0) return;

						return iPipeTo(list, {
							size: 20,
							autocomplete: true,
							message: ' '
						}).then(keys => {
							return keys.forEach((() => {
								var _ref2 = _asyncToGenerator(function* (key) {
									let cleansedKey = function () {
										let tail = key.split(' ')[1];
										let list = StringUtil.getRidOfColors(tail);
										list = StringUtil.getRidOfQuotationMarks(list);
										return list;
									}();

									spawn(`npm info ${cleansedKey} | less -r`, {
										stdio: 'inherit',
										shell: true
									});
								});

								return function (_x) {
									return _ref2.apply(this, arguments);
								};
							})());
						}).catch(err => {
							console.log(err, "Error building interactive interface");
						});
					},

					/***** For API use *****/
					raw: (() => {
						var _ref3 = _asyncToGenerator(function* () {
							if (!list || list.length === 0) return;

							return list;
						});

						return function raw() {
							return _ref3.apply(this, arguments);
						};
					})(),

					rawNoColor: (() => {
						var _ref4 = _asyncToGenerator(function* () {
							if (!list || list.length === 0) return;

							return list.map(function (key) {
								let result = StringUtil.getRidOfColors(key);
								result = StringUtil.getRidOfQuotationMarks(result);
								return result;
							});
						});

						return function rawNoColor() {
							return _ref4.apply(this, arguments);
						};
					})()
				};
			},
			all() {
				let list = parseToList(data).all();
				list.forEach(i => console.log(i));
			}
		};
	});

	return function () {
		return _ref.apply(this, arguments);
	};
})();

/*
 * Parsing with 2 options: simple() offers lazy evaluation, all() evaluates all defined rules
 */
function parseToList(data = {
	'name': '',
	'dist-tags': {
		'latest': ''
	},
	'versions': {}
}) {
	if (!data['name'] || !data['dist-tags'] || !data['versions']) {
		throw new Error('Fetched info is incomplete, therefore useless');
	}

	const title = data['name'] + '@' + data['dist-tags']['latest'];
	const versions = Object.keys(data.versions);
	const dependencies = (() => {
		let latestVersion = versions[versions.length - 1];
		return data.versions[latestVersion].dependencies; // List only the dependencies from that latest release
	})();

	// Chain operation has simple() and all()
	return {
		simple() {
			if (!dependencies) {
				console.log(chalk.blueBright(`${title} has no dependencies`));
				return;
			}
			console.log(chalk.blueBright(`${title}'s Dependencies:`));

			return Object.keys(dependencies).map(key => {
				let value = dependencies[key] ? dependencies[key].replace(/[^0-9.,]/g, "") : '';
				return '├── ' + key + '@' + chalk.grey(value);
			});
		},
		all() {
			console.log(chalk.blueBright(title));
			ui.div({
				text: columnify(dependencies),
				width: 30,
				padding: [0, 2, 0, 2]
			}, {
				text: columnify(versions),
				width: 25,
				padding: [0, 2, 0, 2]
			});

			return ui.toString().split('\n');
		}
	};
}
module.exports.parseToList = parseToList;