5572977410

import * as fs from 'fs';
import { dirname } from 'path';
import opts, { initialize } from './commandOptions';
import dtsgenerator, {
    Schema,
    readSchemaFromStdin,
    readSchemasFromFile,
    readSchemaFromUrl,
} from './core';
import config, { setConfig, showConfig } from './core/config';
import { readConfig } from './utils';

async function loadContents(): Promise<Schema[]> {
    let contents: Schema[] = [];
    const ps: Promise<void>[] = [];
    if (config.input.stdin) {
        ps.push(
            readSchemaFromStdin().then((s) => {
                contents.push(s);
            })
        );
    }
    for (const pattern of config.input.files) {
        ps.push(
            readSchemasFromFile(pattern).then((ss) => {
                contents = contents.concat(ss);
            })
        );
    }
    for (const url of config.input.urls) {
        ps.push(
            readSchemaFromUrl(url).then((s) => {
                contents.push(s);
            })
        );
    }
    await Promise.all(ps);
    return contents;
}

async function exec(): Promise<void> {
    const command = initialize(process.argv);
    const pc = readConfig(opts);
    setConfig(pc);

    if (opts.info) {
        const version = command.opts().version as string;
        await showConfig(version, config);
        return;
    }

    const contents = await loadContents();
    const result = await dtsgenerator({
        contents,
    });
    if (opts.out) {
        fs.mkdirSync(dirname(opts.out), { recursive: true });
        fs.writeFileSync(opts.out, result, { encoding: 'utf-8' });
    } else {
        console.log(result);
    }
}
exec().catch((err: Error) => {
    console.error(err.stack ?? err);
    process.exitCode = 1;
});

1	import * as fs from 'fs';
2	import { dirname } from 'path';
3	import opts, { initialize } from './commandOptions';
4	import dtsgenerator, {
5	Schema,
6	readSchemaFromStdin,
7	readSchemasFromFile,
8	readSchemaFromUrl,
9	} from './core';
10	import config, { setConfig, showConfig } from './core/config';
11	import { readConfig } from './utils';
12
13	async function loadContents(): Promise<Schema[]> {
14	let contents: Schema[] = [];	×
15	const ps: Promise<void>[] = [];	×
16	if (config.input.stdin) {	×
17	ps.push(	×
18	readSchemaFromStdin().then((s) => {
19	contents.push(s);	×
20	})
21	);
22	}
23	for (const pattern of config.input.files) {	×
24	ps.push(	×
25	readSchemasFromFile(pattern).then((ss) => {
26	contents = contents.concat(ss);	×
27	})
28	);
29	}
30	for (const url of config.input.urls) {	×
31	ps.push(	×
32	readSchemaFromUrl(url).then((s) => {
33	contents.push(s);	×
34	})
35	);
36	}
37	await Promise.all(ps);	×
38	return contents;	×
39	}
40
41	async function exec(): Promise<void> {
42	const command = initialize(process.argv);	×
43	const pc = readConfig(opts);	×
44	setConfig(pc);	×
45
46	if (opts.info) {	×
47	const version = command.opts().version as string;	×
48	await showConfig(version, config);	×
49	return;	×
50	}
51
52	const contents = await loadContents();	×
53	const result = await dtsgenerator({	×
54	contents,
55	});
56	if (opts.out) {	×
57	fs.mkdirSync(dirname(opts.out), { recursive: true });	×
58	fs.writeFileSync(opts.out, result, { encoding: 'utf-8' });	×
59	} else {
60	console.log(result);	×
61	}
62	}
63	exec().catch((err: Error) => {	×
64	console.error(err.stack ?? err);	×
65	process.exitCode = 1;	×
66	});

horiuchi / dtsgenerator / 5572977410

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous