Blame view

build/utils.ts 4.73 KB
陈文彬 authored
1
import fs from 'fs';
2
import path from 'path';
陈文彬 authored
3
4
import { networkInterfaces } from 'os';
import dotenv from 'dotenv';
5
import chalk from 'chalk';
6
// import execa from 'execa';
7
陈文彬 authored
8
9
export const isFunction = (arg: unknown): arg is (...args: any[]) => any =>
  typeof arg === 'function';
vben authored
10
陈文彬 authored
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
export const isRegExp = (arg: unknown): arg is RegExp =>
  Object.prototype.toString.call(arg) === '[object RegExp]';

/*
 * Read all files in the specified folder, filter through regular rules, and return file path array
 * @param root Specify the folder path
 * [@param] reg Regular expression for filtering files, optional parameters
 * Note: It can also be deformed to check whether the file path conforms to regular rules. The path can be a folder or a file. The path that does not exist is also fault-tolerant.
 */
export function readAllFile(root: string, reg: RegExp) {
  let resultArr: string[] = [];
  try {
    if (fs.existsSync(root)) {
      const stat = fs.lstatSync(root);
      if (stat.isDirectory()) {
        // dir
        const files = fs.readdirSync(root);
        files.forEach(function (file) {
          const t = readAllFile(root + '/' + file, reg);
          resultArr = resultArr.concat(t);
        });
      } else {
        if (reg !== undefined) {
          if (isFunction(reg.test) && reg.test(root)) {
            resultArr.push(root);
          }
        } else {
          resultArr.push(root);
        }
      }
    }
  } catch (error) {}

  return resultArr;
}
vben authored
47
48
49
/**
 * get client ip address
 */
陈文彬 authored
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
export function getIPAddress() {
  let interfaces = networkInterfaces();
  for (let devName in interfaces) {
    let iFace = interfaces[devName];
    if (!iFace) return;
    for (let i = 0; i < iFace.length; i++) {
      let alias = iFace[i];
      if (alias.family === 'IPv4' && alias.address !== '127.0.0.1' && !alias.internal) {
        return alias.address;
      }
    }
  }

  return '';
}
vben authored
66
export function isDevFn(mode: string): boolean {
67
  return mode === 'development';
陈文彬 authored
68
69
}
vben authored
70
export function isProdFn(mode: string): boolean {
71
  return mode === 'production';
陈文彬 authored
72
73
}
vben authored
74
75
76
/**
 * Whether to generate package preview
 */
陈文彬 authored
77
78
79
export function isReportMode(): boolean {
  return process.env.REPORT === 'true';
}
vben authored
80
81
82
83

/**
 * Whether to generate gzip for packaging
 */
vben authored
84
85
86
export function isBuildGzip(): boolean {
  return process.env.VITE_BUILD_GZIP === 'true';
}
vben authored
87
88
89
90
export interface ViteEnv {
  VITE_PORT: number;
  VITE_USE_MOCK: boolean;
vben authored
91
  VITE_USE_PWA: boolean;
92
93
  VITE_PUBLIC_PATH: string;
  VITE_PROXY: [string, string][];
94
  VITE_GLOB_APP_TITLE: string;
vben authored
95
  VITE_GLOB_APP_SHORT_NAME: string;
96
  VITE_USE_CDN: boolean;
vben authored
97
98
  VITE_DROP_CONSOLE: boolean;
  VITE_BUILD_GZIP: boolean;
vben authored
99
  VITE_DYNAMIC_IMPORT: boolean;
vben authored
100
  VITE_LEGACY: boolean;
101
102
}
vben authored
103
// Read all environment variable configuration files to process.env
104
export function wrapperEnv(envConf: any): ViteEnv {
陈文彬 authored
105
106
  const ret: any = {};
107
108
  for (const envName of Object.keys(envConf)) {
    let realName = envConf[envName].replace(/\\n/g, '\n');
109
110
111
112
113
114
115
116
117
    realName = realName === 'true' ? true : realName === 'false' ? false : realName;
    if (envName === 'VITE_PORT') {
      realName = Number(realName);
    }
    if (envName === 'VITE_PROXY') {
      try {
        realName = JSON.parse(realName);
      } catch (error) {}
    }
陈文彬 authored
118
119
120
121
122
    ret[envName] = realName;
    process.env[envName] = realName;
  }
  return ret;
}
123
vben authored
124
125
126
127
128
/**
 * Get the environment variables starting with the specified prefix
 * @param match prefix
 * @param confFiles ext
 */
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
export function getEnvConfig(match = 'VITE_GLOB_', confFiles = ['.env', '.env.production']) {
  let envConfig = {};
  confFiles.forEach((item) => {
    try {
      const env = dotenv.parse(fs.readFileSync(path.resolve(process.cwd(), item)));

      envConfig = { ...envConfig, ...env };
    } catch (error) {}
  });
  Object.keys(envConfig).forEach((key) => {
    const reg = new RegExp(`^(${match})`);
    if (!reg.test(key)) {
      Reflect.deleteProperty(envConfig, key);
    }
  });
  return envConfig;
}
vben authored
147
function consoleFn(color: string, message: any) {
148
149
  console.log(
    chalk.blue.bold('****************  ') +
vben authored
150
      (chalk as any)[color].bold(message) +
151
152
153
154
      chalk.blue.bold('  ****************')
  );
}
vben authored
155
156
157
158
/**
 * warnConsole
 * @param message
 */
vben authored
159
160
161
162
export function successConsole(message: any) {
  consoleFn('green', '✨ ' + message);
}
vben authored
163
164
165
166
/**
 * warnConsole
 * @param message
 */
167
export function errorConsole(message: any) {
vben authored
168
  consoleFn('red', '✨ ' + message);
169
170
}
vben authored
171
172
173
174
/**
 * warnConsole
 * @param message message
 */
175
export function warnConsole(message: any) {
vben authored
176
  consoleFn('yellow', '✨ ' + message);
177
178
}
vben authored
179
180
181
182
/**
 * Get user root directory
 * @param dir file path
 */
183
184
185
export function getCwdPath(...dir: string[]) {
  return path.resolve(process.cwd(), ...dir);
}
vben authored
186
187
188
// export const run = (bin: string, args: any, opts = {}) =>
//   execa(bin, args, { stdio: 'inherit', ...opts });