Blame view

build/utils.ts 4.99 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
66
67
68
69
70
71
72
73
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 '';
}

export function isDevFn(): boolean {
  return process.env.NODE_ENV === 'development';
}

export function isProdFn(): boolean {
  return process.env.NODE_ENV === 'production';
}
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

/**
 *  Whether to generate package site
 */
vben authored
91
92
93
export function isSiteMode(): boolean {
  return process.env.SITE === 'true';
}
陈文彬 authored
94
95
96
97
export interface ViteEnv {
  VITE_PORT: number;
  VITE_USE_MOCK: boolean;
vben authored
98
  VITE_USE_PWA: boolean;
99
100
  VITE_PUBLIC_PATH: string;
  VITE_PROXY: [string, string][];
101
102
  VITE_GLOB_APP_TITLE: string;
  VITE_USE_CDN: boolean;
vben authored
103
104
  VITE_DROP_CONSOLE: boolean;
  VITE_BUILD_GZIP: boolean;
vben authored
105
  VITE_DYNAMIC_IMPORT: boolean;
106
107
}
vben authored
108
// Read all environment variable configuration files to process.env
109
export function loadEnv(): ViteEnv {
陈文彬 authored
110
111
112
113
114
115
116
117
118
119
  const env = process.env.NODE_ENV;
  const ret: any = {};
  const envList = [`.env.${env}.local`, `.env.${env}`, '.env.local', '.env', ,];
  envList.forEach((e) => {
    dotenv.config({
      path: e,
    });
  });

  for (const envName of Object.keys(process.env)) {
120
121
122
123
124
125
126
127
128
129
    let realName = (process.env as any)[envName].replace(/\\n/g, '\n');
    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
130
131
132
133
134
    ret[envName] = realName;
    process.env[envName] = realName;
  }
  return ret;
}
135
vben authored
136
137
138
139
140
/**
 * Get the environment variables starting with the specified prefix
 * @param match prefix
 * @param confFiles ext
 */
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
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
159
function consoleFn(color: string, message: any) {
160
161
  console.log(
    chalk.blue.bold('****************  ') +
vben authored
162
      (chalk as any)[color].bold(message) +
163
164
165
166
      chalk.blue.bold('  ****************')
  );
}
vben authored
167
168
169
170
/**
 * warnConsole
 * @param message
 */
vben authored
171
172
173
174
export function successConsole(message: any) {
  consoleFn('green', '✨ ' + message);
}
vben authored
175
176
177
178
/**
 * warnConsole
 * @param message
 */
179
export function errorConsole(message: any) {
vben authored
180
  consoleFn('red', '✨ ' + message);
181
182
}
vben authored
183
184
185
186
/**
 * warnConsole
 * @param message message
 */
187
export function warnConsole(message: any) {
vben authored
188
  consoleFn('yellow', '✨ ' + message);
189
190
}
vben authored
191
192
193
194
/**
 * Get user root directory
 * @param dir file path
 */
195
196
197
export function getCwdPath(...dir: string[]) {
  return path.resolve(process.cwd(), ...dir);
}
vben authored
198
199
200
// export const run = (bin: string, args: any, opts = {}) =>
//   execa(bin, args, { stdio: 'inherit', ...opts });