All files / src/cli CLIUtils.ts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
1x
1x
1x
 
 
 
1x
 
1x
 
 
 
1x
 
 
 
 
 
 
1x
 
 
 
 
 
 
4x
 
4x
1x
 
 
3x
1x
 
 
2x
 
 
 
 
 
 
 
 
2x
 
2x
1x
 
 
1x
 
 
2x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
6x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4x
4x
 
1x
 
 
 
 
 
 
 
 
2x
 
 
 
 
 
 
 
2x
 
2x
 
 
 
 
 
import * as fs from 'fs';
import * as mkdirp from 'mkdirp';
import * as path from 'path';
 
import { IPackageConfig } from "../interfaces/IPackageConfig";
 
import { Utils } from "../Utils";
 
export class CLIUtils {
    /**
     * @type {string[]}
     */
    private static availableInputExtensions: string[] = [
        '.js'
    ];
 
    /**
     * @type {BufferEncoding}
     */
    private static encoding: BufferEncoding = 'utf8';
 
    /**
     * @param argv
     * @returns {string}
     */
    public static getInputPath (argv: string[]): string {
        let inputPath: string = argv[0];
 
        if (!CLIUtils.isFilePath(inputPath)) {
            throw new ReferenceError(`First argument must be a valid file path`);
        }
 
        if (!Utils.arrayContains(CLIUtils.availableInputExtensions, path.extname(inputPath))) {
            throw new ReferenceError(`Input file must have .js extension`);
        }
 
        return inputPath;
    }
 
    /**
     * @param commands
     * @param inputPath
     * @returns {string}
     */
    public static getOutputCodePath (commands: commander.ICommand, inputPath: string): string {
        let outputPath: string = (<any>commands).output;
 
        if (outputPath) {
            return outputPath;
        }
 
        return inputPath
            .split('.')
            .map<string>((value: string, index: number) => {
                return index === 0 ? `${value}-obfuscated` : value;
            })
            .join('.');
    }
 
    /**
     * @returns {string}
     */
    public static getOutputSourceMapPath (outputCodePath: string): string {
        return outputCodePath
            .split('.')
            .map<string>((value: string, index: number, array: string[]) => {
                return index === array.length - 1 ? `${value}.map` : value;
            })
            .join('.');
    }
 
    /**
     * @returns {IPackageConfig}
     */
    public static getPackageConfig (): IPackageConfig {
        return <IPackageConfig>JSON.parse(
            fs.readFileSync(
                path.join(
                    path.dirname(
                        fs.realpathSync(process.argv[1])
                    ),
                    '../package.json'
                ),
                CLIUtils.encoding
            )
        );
    }
 
    /**
     * @param filePath
     */
    public static isFilePath (filePath: string): boolean {
        try {
            return fs.statSync(filePath).isFile();
        } catch (e) {
            return false;
        }
    }
 
    /**
     * @param inputPath
     * @returns {string}
     */
    public static readFile (inputPath: string): string {
        return fs.readFileSync(inputPath, CLIUtils.encoding);
    }
 
    /**
     * @param outputPath
     * @param data
     */
    public static writeFile (outputPath: string, data: any): void {
        mkdirp.sync(path.dirname(outputPath));
 
        fs.writeFileSync(outputPath, data, {
            encoding: CLIUtils.encoding
        });
    }
}