export async function run()

in npm/src/main.ts [303:405]
87 lines of code
25 McCabe index (conditional complexity)

export async function run(options: Options): Promise<void> {

	if (options.help) {
		return;
	}

	if (options.version) {
		console.log(require('../package.json').version);
		return;
	}

	let packageFile: string | undefined = options.package;
	if (packageFile === undefined) {
		packageFile = 'package.json';
	}
	packageFile = paths.makeAbsolute(packageFile);
	const packageJson: PackageJson | undefined = PackageJson.read(packageFile);
	let projectRoot = options.projectRoot;
	if (projectRoot === undefined && packageFile !== undefined) {
		projectRoot = path.posix.dirname(packageFile);
		if (!path.isAbsolute(projectRoot)) {
			projectRoot = paths.makeAbsolute(projectRoot);
		}
	}
	if (projectRoot === undefined) {
		console.error(`No project root specified.`);
		process.exitCode = -1;
		return;
	}

	if (!options.stdin && options.in === undefined) {
		console.error(`Either a input file using --in or --stdin must be specified`);
		process.exitCode = -1;
		return;
	}

	if (!options.stdout && options.out === undefined) {
		console.error(`Either a output file using --out or --stdout must be specified.`);
		process.exitCode = -1;
		return;
	}

	if (options.in !== undefined && options.out !== undefined && paths.makeAbsolute(options.in) === paths.makeAbsolute(options.out)) {
		console.error(`Input and output file can't be the same.`);
		process.exitCode = -1;
		return;
	}

	let writer: Writer = new StdoutWriter();
	function emit(value: string | Edge | Vertex): void {
		if (typeof value === 'string') {
			writer.writeln(value);
		} else {
			writer.writeln(JSON.stringify(value, undefined, 0));
		}
	}

	const queue: AttachQueue = new AttachQueue(emit);
	const sourceInfo: SourceInfo = new SourceInfo();
	let exportLinker: ExportLinker | undefined;
	if (packageJson !== undefined) {
		exportLinker = new ExportLinker(sourceInfo, packageJson, queue);
	}
	const importLinker: ImportLinker = new ImportLinker(sourceInfo, queue);
	let input: NodeJS.ReadStream | fs.ReadStream = process.stdin;
	if (options.in !== undefined && fs.existsSync(options.in)) {
		input = fs.createReadStream(options.in, { encoding: 'utf8'});
	}
	if (options.out !== undefined) {
		writer = new FileWriter(fs.openSync(options.out, 'w'));
	}

	let needsInitialization: boolean = true;
	let lastId: Id | undefined;
	const rd = readline.createInterface(input);
	rd.on('line', (line) => {
		emit(line);
		let element: Edge | Vertex = JSON.parse(line);
		lastId = element.id;
		if (needsInitialization) {
			queue.initialize(element.id);
			needsInitialization = false;
		}
		if (element.type === ElementTypes.vertex) {
			switch (element.label) {
				case VertexLabels.moniker:
					if (exportLinker !== undefined) {
						exportLinker.handleMoniker(element);
					}
					importLinker.handleMoniker(element);
					break;
				case VertexLabels.source:
					sourceInfo.handleSource(element);
					break;
			}
		}
	});
	rd.on('close', () => {
		if (lastId !== undefined) {
			queue.flush(lastId);
		}
	});
}