@lcap/builder
Version:
lcap builder utils
233 lines (232 loc) • 9.96 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const vite_1 = require("vite");
const fs_extra_1 = __importDefault(require("fs-extra"));
const path_1 = __importDefault(require("path"));
const parse_imports_1 = require("parse-imports");
const magic_string_1 = __importDefault(require("magic-string"));
const lodash_1 = require("lodash");
const constants_1 = require("../overload/constants");
const config_file_names_1 = require("../constants/config-file-names");
function getLcapUIPkgName(rootPath) {
const pkgPath = path_1.default.resolve(rootPath, constants_1.LCAP_UI_PACKAGE_PATH, config_file_names_1.PKG);
if (fs_extra_1.default.existsSync(pkgPath)) {
const pkg = fs_extra_1.default.readJSONSync(pkgPath);
return pkg.name;
}
return '';
}
function getGlobalName(pkgName) {
return {
'@lcap/element-plus': 'ElementPlus',
'@lcap/element-ui': 'ElementUI',
'@lcap/vant': 'LcapVant',
'@lcap/pc-react-ui': 'antd',
'@lcap/pc-ui': 'CloudUI',
'@lcap/mobile-ui': 'vant',
}[pkgName] || 'LcapUI';
}
function addResolve(config, options, useModules) {
if (!config.resolve) {
config.resolve = {
alias: [],
};
}
else if (!config.resolve.alias) {
config.resolve.alias = [];
}
if (typeof config.resolve.alias === 'object' && !Array.isArray(config.resolve.alias)) {
const alias = [];
const aliasMap = config.resolve.alias;
Object.keys(aliasMap).forEach((k) => {
alias.push({
find: k,
replacement: aliasMap[k],
});
});
config.resolve.alias = alias;
}
const alias = config.resolve.alias;
if (!useModules) {
alias.push({
find: constants_1.LCAP_UI_PACKAGE_NAME,
replacement: path_1.default.resolve(options.rootPath, './.lcap/lcap-ui/runtime/index.js'),
});
}
else {
alias.push({
find: constants_1.LCAP_UI_PACKAGE_NAME,
replacement: path_1.default.resolve(options.rootPath, './.lcap/lcap-ui/package/es/index.mjs'),
});
}
alias.push({
find: constants_1.LCAP_UI_PACKAGE_CSS_NAME,
replacement: path_1.default.resolve(options.rootPath, './.lcap/lcap-ui/runtime/index.css'),
});
}
function getCommonjsOptionsInclude(config) {
if (!config.build || !config.build.commonjsOptions || !config.build.commonjsOptions.include) {
return [];
}
if (!Array.isArray(config.build.commonjsOptions.include)) {
return [config.build.commonjsOptions.include];
}
return config.build.commonjsOptions.include;
}
function setExtenalBuildConfig(config, options, { lcapUIPkgName, command, useModules }) {
var _a;
if (!config.build) {
config.build = {};
}
if (!config.build.rollupOptions) {
config.build.rollupOptions = {};
}
if (!config.optimizeDeps) {
config.optimizeDeps = {
include: [],
};
}
else if (!config.optimizeDeps.include) {
config.optimizeDeps.include = [];
}
config.build.commonjsOptions = Object.assign({}, (config.build.commonjsOptions || {}));
if (!useModules) {
(_a = config.optimizeDeps.include) === null || _a === void 0 ? void 0 : _a.push('virtual-lcap:lcap-ui');
if (config.build.commonjsOptions.requireReturnsDefault === undefined) {
config.build.commonjsOptions.requireReturnsDefault = (id) => {
return id.indexOf('vue/dist/vue.esm.js') !== -1;
};
}
else if (typeof config.build.commonjsOptions.requireReturnsDefault === 'function') {
const temp = config.build.commonjsOptions.requireReturnsDefault;
config.build.commonjsOptions.requireReturnsDefault = (id) => {
if (id.indexOf('vue/dist/vue.esm.js') !== -1) {
return true;
}
return temp(id);
};
}
config.build.commonjsOptions.include = getCommonjsOptionsInclude(config).concat([
'.lcap/lcap-ui/**/*.js',
/node_modules/,
]);
}
if (!config.build.rollupOptions.external) {
config.build.rollupOptions.external = [];
}
// 非库构建不处理默认参数；
if (!config.build.lib && config.build.rollupOptions && config.build.rollupOptions.input) {
return;
}
const globals = config.build.rollupOptions.output.globals || {};
if (lcapUIPkgName) {
config.build.rollupOptions.external.push(lcapUIPkgName);
globals[lcapUIPkgName] = getGlobalName(lcapUIPkgName);
const alias = (config.resolve && config.resolve.alias ? config.resolve.alias : []);
const alia = alias.find((it) => it.find === constants_1.LCAP_UI_PACKAGE_NAME);
if (alia && command === 'build') {
alia.replacement = lcapUIPkgName;
}
}
}
function transformImportCode(code, exportsMap, genURL) {
return __awaiter(this, void 0, void 0, function* () {
const imports = [...(yield (0, parse_imports_1.parseImports)(code))].filter((sp) => sp.moduleSpecifier.value === constants_1.LCAP_UI_PACKAGE_NAME);
if (imports.length === 0) {
return undefined;
}
const s = new magic_string_1.default(code);
imports.forEach((sp) => {
if (!sp.importClause) {
return;
}
const codes = [];
if (sp.importClause.namespace) {
const arr = [];
Object.keys(exportsMap).forEach((name) => {
var _a;
const { src, isDefault } = exportsMap[name];
const key = `${(_a = sp.importClause) === null || _a === void 0 ? void 0 : _a.namespace}_${name}`;
arr.push([name, key]);
codes.push(`import { ${isDefault ? 'default' : name} as ${key} } from '${genURL(src)}'`);
});
codes.push(`const ${sp.importClause.namespace} = { ${arr.map(([name, val]) => `${name}: ${val}`).join(', ')} }`);
}
if (sp.importClause.default && exportsMap.default) {
codes.push(`import { default as ${sp.importClause.default} } from '${genURL(exportsMap.default.src)}'`);
}
if (sp.importClause.named) {
sp.importClause.named.forEach(({ specifier, binding }) => {
const { src, isDefault } = exportsMap[specifier] || {};
if (!src) {
return;
}
codes.push(`import { ${isDefault ? 'default' : specifier} as ${binding} } from '${genURL(src)}'`);
});
}
if (codes.length === 0) {
return;
}
s.overwrite(sp.startIndex, sp.endIndex, codes.join('\n'));
});
return {
code: s.toString(),
get map() {
return s.generateMap({ hires: true, includeContent: true });
},
};
});
}
function lcapUseNaslUI(options) {
const lcapUIConfigPath = path_1.default.resolve(options.rootPath, constants_1.LCAP_UI_JSON_PATH);
const installedLcapUI = fs_extra_1.default.existsSync(lcapUIConfigPath);
if (options.type === 'nasl.ui' || !installedLcapUI) {
return [];
}
const lcapUIConfig = fs_extra_1.default.readJSONSync(lcapUIConfigPath);
const modulesInfoPath = path_1.default.resolve(options.rootPath, constants_1.LCAP_UI_PACKAGE_PATH, lcapUIConfig.modules || 'es/modules.json');
let modulesInfo = null;
if (fs_extra_1.default.existsSync(modulesInfoPath)) {
modulesInfo = fs_extra_1.default.readJSONSync(modulesInfoPath);
}
const useModules = !(0, lodash_1.isNil)(modulesInfo) && modulesInfo.exports && Object.keys(modulesInfo.exports).length > 0;
const lcapUIPkgName = getLcapUIPkgName(options.rootPath);
function generateModulePath(src) {
return (0, vite_1.normalizePath)(path_1.default.resolve(modulesInfoPath, '../', src));
}
return [{
name: 'vite:lcap-use-nasl-ui',
enforce: 'post',
resolveId(id) {
if (id === constants_1.LCAP_UI_PACKAGE_NAME && useModules) {
return generateModulePath('index.mjs');
}
return undefined;
},
transform(code) {
if (!useModules || !modulesInfo || !modulesInfo.exports || options.lcapUIExternal === true) {
return undefined;
}
return transformImportCode(code, modulesInfo.exports, generateModulePath);
},
config(config, { command }) {
addResolve(config, options, useModules);
if (!useModules || options.lcapUIExternal === true) {
setExtenalBuildConfig(config, options, { command, lcapUIPkgName, useModules });
}
},
}];
}
exports.default = lcapUseNaslUI;