'a'

mh-two-thousand-and-two

2024-04-12 44d2c92345cd156a59fc327b3060292a282d2893

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
// const typescript = require('@rollup/plugin-typescript');
const typescript = require('rollup-plugin-typescript2');
const replace = require('@rollup/plugin-replace');
const rollup = require('rollup');
const path = require('path');
const processs = require('process');
const chalk = require('chalk');
const progress = require('./progress');
const UglifyJS = require('uglify-js');
const fs = require('fs');
 
function current() {
    return (new Date()).toLocaleString();
}
 
function createInputOption(env, isWatch) {
    return {
        input: path.resolve(__dirname, '../index.ts'),
        plugins: [
            typescript({
                clean: !isWatch,
                tsconfigOverride: {
                    compilerOptions: {
                        // Rollup don't use CommonJS by default.
                        module: 'ES2015',
                        sourceMap: true,
                        // Use the esm d.ts
                        declaration: false
                    }
                }
            }),
            replace({
                preventAssignment: true,
                'process.env.NODE_ENV': JSON.stringify(env)
            }),
            progress({
                scope: {
                    total: 0
                }
            })
        ]
    };
}
 
const outputOption = {
    format: 'umd',
    file: path.resolve(__dirname, '../dist/zrender.js'),
    sourcemap: true,
    name: 'zrender'
};
 
function minify(outPath) {
    const code = fs.readFileSync(outPath, 'utf-8');
    const uglifyResult = UglifyJS.minify(code);
    if (uglifyResult.error) {
        throw new Error(uglifyResult.error);
    }
    fs.writeFileSync(outPath, uglifyResult.code, 'utf-8');
}
 
if (processs.argv.includes('--watch')) {
    const watcher = rollup.watch({
        ...createInputOption('development', true),
        output: [outputOption],
        watch: {
            clearScreen: true
        }
    });
    watcher.on('event', event => {
        switch(event.code) {
            // case 'START':
            //     console.log(chalk.green('Begin to watch'));
            //     break;
            case 'BUNDLE_START':
                console.log(
                    chalk.gray(current()),
                    chalk.blue('File changed. Begin to bundle')
                );
                break;
            case 'BUNDLE_END':
                console.log(
                    chalk.gray(current()),
                    chalk.green('Finished bundle')
                );
                break;
            case 'ERROR':
                console.log(
                    chalk.gray(current()),
                    chalk.red(event.error)
                );
                break;
        }
    });
}
else {
    // Unminified
    rollup.rollup({
        ...createInputOption('development', false)
    }).then(bundle => {
        bundle.write(outputOption)
            .then(() => {
                // Minified
                if (process.argv.indexOf('--minify') >= 0) {
                    rollup.rollup({
                        ...createInputOption('production', false)
                    }).then(bundle => {
                        const file = outputOption.file.replace(/.js$/, '.min.js');
                        bundle.write(Object.assign(outputOption, {
                            file,
                            sourcemap: false
                        })).then(function () {
                            minify(file);
                        });
                    });
                }
            });
    });
}