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
 
 
 
 
 
 
 
8x
6x
 
 
2x
 
 
4x
 
 
 
 
 
 
 
 
 
5x
5x
1x
 
 
 
 
5x
5x
 
 
 
 
5x
 
 
 
 
 
 
12x
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
11x
11x
 
2x
 
 
 
 
 
 
 
 
6x
 
 
 
 
 
 
11x
2x
 
 
9x
2x
 
 
 
 
 
 
 
 
9x
 
9x
 
 
 
 
 
import * as fs from 'fs';
import * as mkdirp from 'mkdirp';
import * as path from 'path';
 
import { IPackageConfig } from '../interfaces/IPackageConfig';
 
export class CLIUtils {
    /**
     * @type {string[]}
     */
    private static readonly availableInputExtensions: string[] = [
        '.js'
    ];
 
    /**
     * @type {BufferEncoding}
     */
    private static readonly encoding: BufferEncoding = 'utf8';
 
    /**
     * @param outputPath
     * @param inputPath
     * @returns {string}
     */
    public static getOutputCodePath (outputPath: string, inputPath: string): string {
        if (outputPath) {
            return outputPath;
        }
 
        return inputPath
            .split('.')
            .map<string>((value: string, index: number) => {
                return index === 0 ? `${value}-obfuscated` : value;
            })
            .join('.');
    }
 
    /**
     * @param outputCodePath
     * @param sourceMapFileName
     * @returns {string}
     */
    public static getOutputSourceMapPath (outputCodePath: string, sourceMapFileName: string = ''): string {
        if (sourceMapFileName) {
            outputCodePath = `${outputCodePath.substr(
                0, outputCodePath.lastIndexOf('/')
            )}/${sourceMapFileName}`;
        }
 
        Eif (!/\.js\.map$/.test(outputCodePath)) {
            outputCodePath = `${outputCodePath.split('.')[0]}.js.map`;
        } else if (/\.js$/.test(outputCodePath)) {
            outputCodePath += '.map';
        }
 
        return outputCodePath;
    }
 
    /**
     * @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 inputPath
     */
    public static validateInputPath (inputPath: string): void {
        if (!CLIUtils.isFilePath(inputPath)) {
            throw new ReferenceError(`Given input path must be a valid file path`);
        }
 
        if (!CLIUtils.availableInputExtensions.includes(path.extname(inputPath))) {
            throw new ReferenceError(`Input file must have .js extension`);
        }
    }
 
    /**
     * @param outputPath
     * @param data
     */
    public static writeFile (outputPath: string, data: any): void {
        mkdirp.sync(path.dirname(outputPath));
 
        fs.writeFileSync(outputPath, data, {
            encoding: CLIUtils.encoding
        });
    }
}