mirror of
https://github.com/pure-admin/vue-pure-admin.git
synced 2025-06-08 09:27:19 +08:00
257 lines
9.1 KiB
JavaScript
257 lines
9.1 KiB
JavaScript
"use strict";
|
|
var __importDefault = (this && this.__importDefault) || function (mod) {
|
|
return (mod && mod.__esModule) ? mod : { "default": mod };
|
|
};
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.defaultDefines = exports.resolveConfig = void 0;
|
|
const path_1 = __importDefault(require("path"));
|
|
const fs_extra_1 = __importDefault(require("fs-extra"));
|
|
const chalk_1 = __importDefault(require("chalk"));
|
|
const dotenv_1 = __importDefault(require("dotenv"));
|
|
const dotenv_expand_1 = __importDefault(require("dotenv-expand"));
|
|
const buildPluginEsbuild_1 = require("./build/buildPluginEsbuild");
|
|
const resolver_1 = require("./resolver");
|
|
const utils_1 = require("./utils");
|
|
const debug = require('debug')('vite:config');
|
|
async function resolveConfig(mode, configPath) {
|
|
const start = Date.now();
|
|
const cwd = process.cwd();
|
|
let config;
|
|
let resolvedPath;
|
|
let isTS = false;
|
|
if (configPath) {
|
|
resolvedPath = path_1.default.resolve(cwd, configPath);
|
|
}
|
|
else {
|
|
const jsConfigPath = path_1.default.resolve(cwd, 'vite.config.js');
|
|
if (fs_extra_1.default.existsSync(jsConfigPath)) {
|
|
resolvedPath = jsConfigPath;
|
|
}
|
|
else {
|
|
const tsConfigPath = path_1.default.resolve(cwd, 'vite.config.ts');
|
|
if (fs_extra_1.default.existsSync(tsConfigPath)) {
|
|
isTS = true;
|
|
resolvedPath = tsConfigPath;
|
|
}
|
|
}
|
|
}
|
|
if (!resolvedPath) {
|
|
// load environment variables
|
|
return {
|
|
env: loadEnv(mode, cwd)
|
|
};
|
|
}
|
|
try {
|
|
if (!isTS) {
|
|
try {
|
|
config = require(resolvedPath);
|
|
}
|
|
catch (e) {
|
|
if (!/Cannot use import statement|Unexpected token 'export'|Must use import to load ES Module/.test(e.message)) {
|
|
throw e;
|
|
}
|
|
}
|
|
}
|
|
if (!config) {
|
|
// 2. if we reach here, the file is ts or using es import syntax, or
|
|
// the user has type: "module" in their package.json (#917)
|
|
// transpile es import syntax to require syntax using rollup.
|
|
const rollup = require('rollup');
|
|
const esbuildPlugin = await buildPluginEsbuild_1.createEsbuildPlugin({});
|
|
const esbuildRenderChunkPlugin = buildPluginEsbuild_1.createEsbuildRenderChunkPlugin('es2019', false);
|
|
// use node-resolve to support .ts files
|
|
const nodeResolve = require('@rollup/plugin-node-resolve').nodeResolve({
|
|
extensions: resolver_1.supportedExts
|
|
});
|
|
const bundle = await rollup.rollup({
|
|
external: (id) => (id[0] !== '.' && !path_1.default.isAbsolute(id)) ||
|
|
id.slice(-5, id.length) === '.json',
|
|
input: resolvedPath,
|
|
treeshake: false,
|
|
plugins: [esbuildPlugin, nodeResolve, esbuildRenderChunkPlugin]
|
|
});
|
|
const { output: [{ code }] } = await bundle.generate({
|
|
exports: 'named',
|
|
format: 'cjs'
|
|
});
|
|
config = await loadConfigFromBundledFile(resolvedPath, code);
|
|
}
|
|
if (typeof config === 'function') {
|
|
config = config(mode);
|
|
}
|
|
// normalize config root to absolute
|
|
if (config.root && !path_1.default.isAbsolute(config.root)) {
|
|
config.root = path_1.default.resolve(path_1.default.dirname(resolvedPath), config.root);
|
|
}
|
|
if (typeof config.vueTransformAssetUrls === 'object') {
|
|
config.vueTransformAssetUrls = normalizeAssetUrlOptions(config.vueTransformAssetUrls);
|
|
}
|
|
// resolve plugins
|
|
if (config.plugins) {
|
|
for (const plugin of config.plugins) {
|
|
config = resolvePlugin(config, plugin);
|
|
}
|
|
}
|
|
config.env = {
|
|
...config.env,
|
|
...loadEnv(mode, config.root || cwd)
|
|
};
|
|
debug(`config resolved in ${Date.now() - start}ms`);
|
|
config.__path = resolvedPath;
|
|
return config;
|
|
}
|
|
catch (e) {
|
|
console.error(chalk_1.default.red(`[vite] failed to load config from ${resolvedPath}:`));
|
|
console.error(e);
|
|
process.exit(1);
|
|
}
|
|
}
|
|
exports.resolveConfig = resolveConfig;
|
|
async function loadConfigFromBundledFile(fileName, bundledCode) {
|
|
const extension = path_1.default.extname(fileName);
|
|
const defaultLoader = require.extensions[extension];
|
|
require.extensions[extension] = (module, filename) => {
|
|
if (filename === fileName) {
|
|
;
|
|
module._compile(bundledCode, filename);
|
|
}
|
|
else {
|
|
defaultLoader(module, filename);
|
|
}
|
|
};
|
|
delete require.cache[fileName];
|
|
const raw = require(fileName);
|
|
const config = raw.__esModule ? raw.default : raw;
|
|
require.extensions[extension] = defaultLoader;
|
|
return config;
|
|
}
|
|
function resolvePlugin(config, plugin) {
|
|
return {
|
|
...config,
|
|
...plugin,
|
|
alias: {
|
|
...plugin.alias,
|
|
...config.alias
|
|
},
|
|
define: {
|
|
...plugin.define,
|
|
...config.define
|
|
},
|
|
transforms: [...(config.transforms || []), ...(plugin.transforms || [])],
|
|
indexHtmlTransforms: [
|
|
...(config.indexHtmlTransforms || []),
|
|
...(plugin.indexHtmlTransforms || [])
|
|
],
|
|
resolvers: [...(config.resolvers || []), ...(plugin.resolvers || [])],
|
|
configureServer: [].concat(config.configureServer || [], plugin.configureServer || []),
|
|
configureBuild: [].concat(config.configureBuild || [], plugin.configureBuild || []),
|
|
vueCompilerOptions: {
|
|
...config.vueCompilerOptions,
|
|
...plugin.vueCompilerOptions
|
|
},
|
|
vueTransformAssetUrls: mergeAssetUrlOptions(config.vueTransformAssetUrls, plugin.vueTransformAssetUrls),
|
|
vueTemplatePreprocessOptions: {
|
|
...config.vueTemplatePreprocessOptions,
|
|
...plugin.vueTemplatePreprocessOptions
|
|
},
|
|
vueCustomBlockTransforms: {
|
|
...config.vueCustomBlockTransforms,
|
|
...plugin.vueCustomBlockTransforms
|
|
},
|
|
rollupInputOptions: mergeObjectOptions(config.rollupInputOptions, plugin.rollupInputOptions),
|
|
rollupOutputOptions: mergeObjectOptions(config.rollupOutputOptions, plugin.rollupOutputOptions),
|
|
enableRollupPluginVue: config.enableRollupPluginVue || plugin.enableRollupPluginVue
|
|
};
|
|
}
|
|
function mergeAssetUrlOptions(to, from) {
|
|
if (from === true) {
|
|
return to;
|
|
}
|
|
if (from === false) {
|
|
return from;
|
|
}
|
|
if (typeof to === 'boolean') {
|
|
return from || to;
|
|
}
|
|
return {
|
|
...normalizeAssetUrlOptions(to),
|
|
...normalizeAssetUrlOptions(from)
|
|
};
|
|
}
|
|
function normalizeAssetUrlOptions(o) {
|
|
if (o && Object.keys(o).some((key) => Array.isArray(o[key]))) {
|
|
return {
|
|
tags: o
|
|
};
|
|
}
|
|
else {
|
|
return o;
|
|
}
|
|
}
|
|
function mergeObjectOptions(to, from) {
|
|
if (!to)
|
|
return from;
|
|
if (!from)
|
|
return to;
|
|
const res = { ...to };
|
|
for (const key in from) {
|
|
const existing = res[key];
|
|
const toMerge = from[key];
|
|
if (Array.isArray(existing) || Array.isArray(toMerge)) {
|
|
res[key] = [].concat(existing, toMerge).filter(Boolean);
|
|
}
|
|
else {
|
|
res[key] = toMerge;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
function loadEnv(mode, root) {
|
|
if (mode === 'local') {
|
|
throw new Error(`"local" cannot be used as a mode name because it conflicts with ` +
|
|
`the .local postfix for .env files.`);
|
|
}
|
|
debug(`env mode: ${mode}`);
|
|
const clientEnv = {};
|
|
const envFiles = [
|
|
/** mode local file */ `.env.${mode}.local`,
|
|
/** mode file */ `.env.${mode}`,
|
|
/** local file */ `.env.local`,
|
|
/** default file */ `.env`
|
|
];
|
|
for (const file of envFiles) {
|
|
const path = utils_1.lookupFile(root, [file], true);
|
|
if (path) {
|
|
// NOTE: this mutates process.env
|
|
const { parsed, error } = dotenv_1.default.config({
|
|
debug: !!process.env.DEBUG || undefined,
|
|
path
|
|
});
|
|
if (!parsed) {
|
|
throw error;
|
|
}
|
|
// NOTE: this mutates process.env
|
|
dotenv_expand_1.default({ parsed });
|
|
// set NODE_ENV under a different key so that we know this is set from
|
|
// vite-loaded .env files. Some users may have default NODE_ENV set in
|
|
// their system.
|
|
if (parsed.NODE_ENV) {
|
|
process.env.VITE_ENV = parsed.NODE_ENV;
|
|
}
|
|
// only keys that start with VITE_ are exposed.
|
|
for (const [key, value] of Object.entries(parsed)) {
|
|
if (key.startsWith(`VITE_`)) {
|
|
clientEnv[key] = value;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
debug(`env: %O`, clientEnv);
|
|
return clientEnv;
|
|
}
|
|
// TODO move this into Vue plugin when we extract it
|
|
exports.defaultDefines = {
|
|
__VUE_OPTIONS_API__: true,
|
|
__VUE_PROD_DEVTOOLS__: false
|
|
};
|
|
//# sourceMappingURL=config.js.map
|