@omnia/tooling-vue
Version:
Used to bundle and serve manifests web component that build on Vue framework.
176 lines (175 loc) • 8.47 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.registerWebpackMiddleware = void 0;
const tslib_1 = require("tslib");
const webpack_1 = require("webpack");
const webpack_dev_middleware_1 = tslib_1.__importDefault(require("webpack-dev-middleware"));
const path_1 = tslib_1.__importDefault(require("path"));
const $ = tslib_1.__importStar(require("../../variables"));
const bundler = tslib_1.__importStar(require("../../tasks/bundle"));
const tooling_1 = require("@omnia/tooling");
const tooling_composers_1 = require("@omnia/tooling-composers");
const fx_models_1 = require("@omnia/fx-models");
const OmniaMiddleware_1 = require("./OmniaMiddleware");
let _webpackDevMiddlewareInstance = null;
let _server = null;
let _errorMessage = '';
function registerWebpackMiddleware(server) {
_server = server;
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.BundleManifest,
order: 3,
task: function (entries) {
return registerWebpackMiddleWareBundle(entries);
}
});
}
exports.registerWebpackMiddleware = registerWebpackMiddleware;
function registerWebpackMiddleWareBundle(entries) {
_server.httpServer.on('upgrade', (req, socket, head) => {
// have new connection
if (req.headers['sec-websocket-protocol'] === 'vite-hmr') {
if (_errorMessage) {
sendMessage({
err: Object.create({
message: _errorMessage
}),
type: fx_models_1.LocalServingMessageType.Error
});
}
}
});
OmniaMiddleware_1.ManifestChangedMessage.subcribe(() => {
if (_webpackDevMiddlewareInstance) {
_webpackDevMiddlewareInstance.close();
}
});
tooling_1.utils.registerLogToClient((message, type) => {
_errorMessage = message;
sendMessage({
err: Object.create({
message: _errorMessage
}),
type: fx_models_1.LocalServingMessageType.Error
});
});
return new Promise(function (resolve, reject) {
$.tooling.log("Webpack Middleware running...");
if (_webpackDevMiddlewareInstance) {
_webpackDevMiddlewareInstance.close();
}
let _initialized = false;
const hosting = (0, tooling_composers_1.getHosting)();
let configs = buildWebpackEntries(entries);
let webpackCompiler = (0, webpack_1.webpack)(configs);
let statOptions = {
//errorStack: false,
children: webpackCompiler.compilers.map(comp => Object.assign({ preset: 'errors-only', colors: false, errorStack: false }))
};
webpackCompiler.hooks.done.tap("omnia-done", stats => {
if (_initialized) {
const errorStats = stats.toString(statOptions);
if (errorStats) {
_errorMessage = errorStats;
sendMessage({
type: fx_models_1.LocalServingMessageType.Error,
err: Object.create({
message: _errorMessage
})
});
}
else if (!bundler.checkDuplicateBundle()) {
_errorMessage = null;
sendMessage({
type: fx_models_1.LocalServingMessageType.Update
});
}
}
});
_webpackDevMiddlewareInstance = (0, webpack_dev_middleware_1.default)(webpackCompiler, {
writeToDisk: (filePath) => {
if (OmniaMiddleware_1.resolvableManifest?.resolved) {
if (_initialized) {
let manifestId = $.tooling.utils.getGuidValue(filePath);
if (manifestId) {
let manifest = $.tooling.composer.getManifestById(manifestId);
if (manifest) {
let manifestsData = $.tooling.composer.getManifestData();
let bundleType = path_1.default.extname(filePath).replace('.', '');
manifest.version = manifest.version || {};
manifest.version[bundleType] = $.tooling.utils.generateGuid().replace(/-/g, '');
$.tooling.composer.updateManifestData(manifestsData);
// check if the manifest in agroup
if (manifestsData.groupedResouresAndComponents) {
let manifestGroup = manifestsData.groupedResouresAndComponents.find(g => g.manifestIdsInGroup.indexOf(manifestId) > -1);
if (manifestGroup) {
setTimeout(() => {
if (OmniaMiddleware_1.resolvableManifest?.resolved) {
bundler.createCombinedManfest(bundler.getServiceId(), manifestGroup.manifestIdsInGroup, manifestGroup.resourceId, manifestGroup.resourceName, $.tooling.composer.OmniaOutput.OutputBundlePath).then(() => {
tooling_1.utils.log(`Webpack bundle changed -> ${manifestGroup.resourceName ? manifestGroup.resourceName + '_' : ''}${manifestGroup.resourceId}.js`);
manifestGroup.version = manifest.version || {};
manifestGroup.version['js'] = $.tooling.utils.generateGuid().replace(/-/g, '');
$.tooling.composer.updateManifestData(manifestsData);
});
}
}, 100);
}
}
if (!_errorMessage && hosting.disableAutoReload !== true) {
bundler.ensureManifestDependencyInRuntime(manifestId, filePath);
tooling_1.utils.timeWatch("registerWebpackMiddleWareBundle_autoreload", () => {
sendMessage({ type: fx_models_1.LocalServingMessageType.FullReload });
}, 200);
}
//_webpackCompiler.
tooling_1.utils.log(`Webpack bundle changed -> ${path_1.default.basename(filePath)}&v=${manifest.version[bundleType]}`);
}
}
}
}
return true;
}
});
_webpackDevMiddlewareInstance.waitUntilValid(() => {
if (bundler.checkDuplicateBundle()) { // detect duplicated bundle
tooling_1.utils.log('Bundle manifest have error that found duplicated bundles', $.tooling.LogTypes.Error);
// reject();
// process.exit();
}
tooling_1.utils.log("Webpack Middleware done");
_initialized = true;
resolve(entries);
});
});
}
function buildWebpackEntries(entries) {
let configs = [];
let bundleOptions = bundler.getBuildOption().bundleOptions;
if (bundleOptions && bundleOptions.commonsChunk) {
let config = bundler.createVueWebpackConfig(null, entries, $.tooling.composer.OmniaOutput.OutputBundlePath);
config.stats = 'errors-only';
config.watchOptions = {
aggregateTimeout: 200
};
configs.push(config);
}
else {
configs = Object.keys(entries).map(key => {
var entry = {};
entry[key] = entries[key];
let config = bundler.createVueWebpackConfig(entry, entries, $.tooling.composer.OmniaOutput.OutputBundlePath);
config.stats = 'errors-only';
config.watchOptions = {
aggregateTimeout: 200
};
return config;
});
}
configs.forEach(config => {
config.output.path = $.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath);
});
return configs;
}
function sendMessage(message) {
_server.ws.send(message);
}