@omnia/tooling-vue
Version:
Used to bundle and serve manifests web component that build on Vue framework.
329 lines (328 loc) • 16.7 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.tempFix = exports.replaceWildcardDefaultExport = exports.replaceNamelessDefaultExport = exports.getDependencyStatements = exports.analyze = void 0;
const tslib_1 = require("tslib");
const fs_1 = tslib_1.__importDefault(require("fs"));
const path_1 = tslib_1.__importDefault(require("path"));
const vite_1 = require("vite");
const envUtils = tslib_1.__importStar(require("./env"));
const pathUtils = tslib_1.__importStar(require("./path"));
const replacedDefaultVariable = '__default__';
const commentRegex = new RegExp(/\/\*[\s\S]*?\*\/|\/\/.*/g);
const namedObjectVariableRegex = new RegExp(/(\w+|\d*)(?:\s+as\s+)(\w+\d*)|(\w+\d*)/g);
const dependencyRegex = new RegExp(/((import)(\s+|(\s+.[\n\r]*))[^\'\"]*[\'\"].+[\'\"])|((export)(\s+|(\s+.[\n\r]*))(?:(?!from).[\n\r]*)+(from)(?:\s*)[\'\"].+[\'\"])/g);
const importedNamedVariablesRegex = new RegExp(/(?:import)(?:\s*)(?:{)([\w\d\s,]+)(?:})(?:\s*from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const importedWildcardVariablesRegex = new RegExp(/(?:import)(?:\s*)(?:\*\s+as\s+)(\w+\d*)\s+(?:from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const importedDefaultVariablesRegex = new RegExp(/(?:import)(?:\s+)(\w+|\d*)\s+(?:from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const importedNoneVariablesRegex = new RegExp(/(?:import)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const exportedLocalsRegex = new RegExp(/(?:export)(?:\s+)(?:class|function|const|let|var)(?:\s+)(\w+|\d*)/g);
const exportedLocalDefaultRegex = new RegExp(/export\s+default\s+(?:function|class)\s+([\w\d]+)/g);
const exportedLocalNamedVariablesRegex = new RegExp(/(?:export)(?:\s*)(?:{)([\w\d\s,]+)(?:})(?!\s*from)/g);
const exportedExternalNamedVariablesRegex = new RegExp(/(?:export)(?:\s*)(?:{)([\w\d\s,]+)(?:})(?:\s*from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const exportedWildcardVariablesRegex = new RegExp(/(?:export)(?:\s*)(?:\*\s+as\s+)(\w+\d*)\s+(?:from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const exportedWildcardsRegex = new RegExp(/(?:export)(?:\s*)(?:\*)\s*(?:from)(?:\s*)[\'\"]([\w\d./@_-]+)[\'\"]/g);
const exportedNamelessDefaultRegex = new RegExp(/export\s+default\s+(?!(function|class)\s+([\w\d]+))/g);
const commonJsRequireRegex = new RegExp(/require\(\s*['"]([\w\d./@_-]+)['"]\s*\)/g);
function analyze(code, id) {
const removedCommentsCode = code.replace(commentRegex, '');
const commonJsRequires = getCommonJsRequireRegex(removedCommentsCode, id);
const importedNamedVariables = getImportedNamedVariables(removedCommentsCode, id);
const importedWildcardVariables = getImportedWildcardVariables(removedCommentsCode, id);
const importedDefaultVariables = getImportedDefaultVariables(removedCommentsCode, id);
const importedNoneVariables = getImportedNoneVariablesRegex(removedCommentsCode, id);
const exportedLocals = getExportedLocals(removedCommentsCode);
const exportedLocalDefault = getExportedLocalDefault(removedCommentsCode);
const exportedLocalNamedVariables = getExportedLocalNamedVariables(removedCommentsCode);
const exportedExternalNamedVariables = getExportedExternalNamedVariables(removedCommentsCode, id);
const exportedWildcardVariables = getExportedWildcardVariables(removedCommentsCode, id);
const exportedWildcards = getExportedWildcards(removedCommentsCode, id);
const namelessDefaultExport = hasNamelessDefaultExport(removedCommentsCode);
const defaultExportInLocalNamedVariables = exportedLocalNamedVariables.find(i => !!i.default);
const defaultExportInExternalNamedVariables = exportedExternalNamedVariables.find(i => !!i.default);
const defaultExportInWildcardVariables = exportedWildcardVariables.find(i => i.defaultAvailable);
const importPaths = [
...commonJsRequires.map(i => i.path),
...importedNamedVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
...importedWildcardVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
...importedDefaultVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
...importedNoneVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
].filter((value, index, array) => array.indexOf(value) == index);
const exportPaths = [
...exportedExternalNamedVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
...exportedWildcardVariables.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
...exportedWildcards.reduce((prevVal, curVal) => prevVal.concat(curVal.path), []),
].filter((value, index, array) => array.indexOf(value) == index);
const namedExports = [
...exportedLocals,
...exportedLocalNamedVariables.reduce((prevVal, curVal) => prevVal.concat(mapVariableNames(curVal)), []),
...exportedExternalNamedVariables.reduce((prevVal, curVal) => prevVal.concat(mapVariableNames(curVal)), []),
...exportedWildcardVariables.reduce((prevVal, curVal) => curVal.defaultAvailable ? prevVal : prevVal.concat(curVal.value), [])
];
const defaultExport = {
available: !!defaultExportInLocalNamedVariables ||
!!defaultExportInExternalNamedVariables ||
!!defaultExportInWildcardVariables ||
namelessDefaultExport ||
!!exportedLocalDefault,
wildcard: defaultExportInWildcardVariables,
nameless: namelessDefaultExport,
original: !!defaultExportInLocalNamedVariables ? defaultExportInLocalNamedVariables.default :
!!defaultExportInExternalNamedVariables ? defaultExportInExternalNamedVariables.default :
!!defaultExportInWildcardVariables ? replacedDefaultVariable :
namelessDefaultExport ? replacedDefaultVariable :
!!exportedLocalDefault ? exportedLocalDefault : undefined,
path: !!defaultExportInExternalNamedVariables ? defaultExportInExternalNamedVariables.path :
!!defaultExportInWildcardVariables ? defaultExportInWildcardVariables.path : undefined
};
const metadata = {
importPaths,
exportPaths,
namedExports,
imports: {
namedVariables: importedNamedVariables,
wildcardVariables: importedWildcardVariables,
defaultVariables: importedDefaultVariables,
noneVariables: importedNoneVariables
},
exports: {
locals: exportedLocals,
localNamedVariables: exportedLocalNamedVariables,
externalNamedVariables: exportedExternalNamedVariables,
wildcardVariables: exportedWildcardVariables,
wildcards: exportedWildcards,
default: defaultExport
},
requires: commonJsRequires
};
return metadata;
}
exports.analyze = analyze;
function getDependencyStatements(code) {
const removedCommentsCode = code.replace(commentRegex, '');
const dependencyStatements = removedCommentsCode.match(dependencyRegex);
return dependencyStatements;
}
exports.getDependencyStatements = getDependencyStatements;
function replaceNamelessDefaultExport(code) {
code = code.replace(exportedNamelessDefaultRegex, `const ${replacedDefaultVariable} = `);
code += `\nexport default ${replacedDefaultVariable};`;
return code;
}
exports.replaceNamelessDefaultExport = replaceNamelessDefaultExport;
function replaceWildcardDefaultExport(code, wildcard) {
if (!wildcard.defaultAvailable) {
return code;
}
code = code.replace(wildcard.statement, `import * as ${replacedDefaultVariable} from '${wildcard.rawPath}'\nexport default ${replacedDefaultVariable}`);
return code;
}
exports.replaceWildcardDefaultExport = replaceWildcardDefaultExport;
function tempFix(id, code, fromWorker) {
const imageFilePaths = [];
let transformedCode = code;
const removedCommentsCode = code.replace(commentRegex, '');
const dependencyStatements = removedCommentsCode.match(dependencyRegex);
if (dependencyStatements && dependencyStatements.length > 0) {
dependencyStatements.forEach(statement => {
const quoteChar = statement.includes('\'') ? '\'' : '\"';
const modulePath = statement.split(quoteChar)[1];
if (pathUtils.isImageFilePath(modulePath)) {
imageFilePaths.push(modulePath);
transformedCode = transformedCode.replace(statement, '');
}
if (fromWorker) {
const workerModulePath = pathUtils.modify(modulePath).appendWorkerIdentifier(true).getValue();
const newStatement = statement.replace(modulePath, workerModulePath);
transformedCode = transformedCode.replace(statement, newStatement);
}
});
}
// replace importScripts with shimport function
if (fromWorker) {
transformedCode = transformedCode.replace(/importScripts\(/g, '__import(');
}
imageFilePaths.forEach(filePath => {
const source = path_1.default.join(path_1.default.dirname(id), filePath);
const dest = path_1.default.join(envUtils.getImageOutputDirPath(), path_1.default.basename(filePath));
fs_1.default.copyFileSync(source, dest);
});
return transformedCode;
}
exports.tempFix = tempFix;
function resolveRawPath(rawPath, id, external) {
let dependencyFilePath;
if (rawPath.startsWith('.')) {
const moduleGuessPath = path_1.default.join(path_1.default.dirname(id), rawPath);
dependencyFilePath = pathUtils.resolveModulePath(moduleGuessPath, external);
}
else if (pathUtils.isTsPath(rawPath)) {
dependencyFilePath = pathUtils.resolveTsPath(rawPath);
}
if (dependencyFilePath) {
dependencyFilePath = dependencyFilePath.replace((0, vite_1.normalizePath)(envUtils.getRootDirPath()), '');
if (dependencyFilePath.startsWith('/')) {
dependencyFilePath = '.' + dependencyFilePath;
}
else {
dependencyFilePath = './' + dependencyFilePath;
}
return dependencyFilePath;
}
return rawPath; // bare import (node_modules)
}
function mapVariableNames(item) {
const names = item.values;
const asNames = Object.keys(item.asValues).map(k => item.asValues[k]);
return [...names, ...asNames];
}
function getImportedNamedVariables(code, id) {
const iterator = code.matchAll(importedNamedVariablesRegex);
const result = Array.from(iterator, item => ({
statement: item[0],
variableStatement: item[1],
rawPath: item[2]
})).reduce((imports, current) => {
const namedVariables = [];
current.variableStatement.split(',').filter(text => text.trim().length > 0).forEach(text => {
const info = Array.from(text.matchAll(namedObjectVariableRegex), item => {
if (item[3]) {
return { value: item[3] };
}
return {
value: item[2],
original: item[1]
};
});
namedVariables.push(...info);
}, []);
const variables = namedVariables.filter(i => !i.original).map(i => i.value);
const asVariables = namedVariables.filter(i => !!i.original).reduce((prevVal, curVal) => {
prevVal[curVal.original] = curVal.value;
return prevVal;
}, {});
imports.push({
statement: current.statement,
rawPath: current.rawPath,
path: resolveRawPath(current.rawPath, id),
values: variables,
asValues: asVariables
});
return imports;
}, []);
return result;
}
function getImportedWildcardVariables(code, id) {
const iterator = code.matchAll(importedWildcardVariablesRegex);
return Array.from(iterator, item => ({ statement: item[0], value: item[1], rawPath: item[2], path: resolveRawPath(item[2], id) }));
}
function getImportedDefaultVariables(code, id) {
const iterator = code.matchAll(importedDefaultVariablesRegex);
return Array.from(iterator, item => ({ statement: item[0], default: item[1], rawPath: item[2], path: resolveRawPath(item[2], id) }));
}
function getImportedNoneVariablesRegex(code, id) {
const iterator = code.matchAll(importedNoneVariablesRegex);
return Array.from(iterator, item => ({ statement: item[0], rawPath: item[1], path: resolveRawPath(item[1], id) }));
}
function getExportedLocals(code) {
const iterator = code.matchAll(exportedLocalsRegex);
return Array.from(iterator, item => item[1]);
}
function getExportedLocalDefault(code) {
const iterator = code.matchAll(exportedLocalDefaultRegex);
const items = Array.from(iterator, item => ({ value: item[1] }));
if (items.length > 0) {
return items[0].value;
}
}
function getExportedLocalNamedVariables(code) {
const iterator = code.matchAll(exportedLocalNamedVariablesRegex);
const result = Array.from(iterator, item => item[1]).reduce((namedExports, currentStatement) => {
const exports = [];
currentStatement.split(',').filter(text => text.trim().length > 0).forEach(text => {
const info = Array.from(text.matchAll(namedObjectVariableRegex), item => {
if (item[3]) {
return { value: item[3] };
}
return {
value: item[2],
original: item[1]
};
});
exports.push(...info);
}, []);
const variables = exports.filter(i => !i.original).map(i => i.value);
const defaultExport = exports.find(i => !!i.original && i.value == 'default')?.original;
const asVariables = exports.filter(i => !!i.original && i.value != 'default').reduce((prevVal, curVal) => {
prevVal[curVal.original] = curVal.value;
return prevVal;
}, {});
namedExports.push({
values: variables,
asValues: asVariables,
default: defaultExport
});
return namedExports;
}, []);
return result;
}
function getExportedExternalNamedVariables(code, id) {
const iterator = code.matchAll(exportedExternalNamedVariablesRegex);
const result = Array.from(iterator, item => ({
statement: item[0],
variableStatement: item[1],
rawPath: item[2]
})).reduce((namedExports, current) => {
const exports = [];
current.variableStatement.split(',').filter(text => text.trim().length > 0).forEach(text => {
const info = Array.from(text.matchAll(namedObjectVariableRegex), item => {
if (item[3]) {
return { value: item[3] };
}
return {
value: item[2],
original: item[1]
};
});
exports.push(...info);
}, []);
const variables = exports.filter(i => !i.original).map(i => i.value);
const defaultExport = exports.find(i => !!i.original && i.value == 'default')?.original;
const asVariables = exports.filter(i => !!i.original && i.value != 'default').reduce((prevVal, curVal) => {
prevVal[curVal.original] = curVal.value;
return prevVal;
}, {});
namedExports.push({
statement: current.statement,
rawPath: current.rawPath,
path: resolveRawPath(current.rawPath, id),
values: variables,
asValues: asVariables,
default: defaultExport
});
return namedExports;
}, []);
return result;
}
function getExportedWildcardVariables(code, id) {
const iterator = code.matchAll(exportedWildcardVariablesRegex);
const items = Array.from(iterator, item => ({ statement: item[0], value: item[1], rawPath: item[2] }));
return items.map(item => ({
statement: item.statement,
rawPath: item.rawPath,
path: resolveRawPath(item.rawPath, id),
value: item.value,
defaultAvailable: item.value == 'default'
}));
}
function getExportedWildcards(code, id) {
const iterator = code.matchAll(exportedWildcardsRegex);
return Array.from(iterator, item => ({ statement: item[0], rawPath: item[1], path: resolveRawPath(item[1], id) }));
}
function getCommonJsRequireRegex(code, id) {
const iterator = code.matchAll(commonJsRequireRegex);
return Array.from(iterator, item => ({ statement: item[0], rawPath: item[1], path: resolveRawPath(item[1], id, true) }));
}
function hasNamelessDefaultExport(code) {
const result = code.match(exportedNamelessDefaultRegex);
return result && result.length > 0;
}