@omnia/tooling-vue
Version:
Used to bundle and serve manifests web component that build on Vue framework.
1,076 lines (1,074 loc) • 81.4 kB
JavaScript
'use strict';
Object.defineProperty(exports, "__esModule", { value: true });
exports.addDependency = exports.processManifestGenerated = exports.checkDuplicateBundle = exports.registerWebComponentDefinitions = exports.registerManifestsReference = exports.createCombinedManfest = exports.createVueWebpackConfig = exports.cleanUpComposer = exports.getBuildOption = exports.getServiceId = exports.bundleManifest = exports.ensureManifestDependencyInRuntime = void 0;
const tslib_1 = require("tslib");
const path_1 = tslib_1.__importDefault(require("path"));
const del_1 = tslib_1.__importDefault(require("del"));
const fsExtra = tslib_1.__importStar(require("fs-extra"));
const globby = tslib_1.__importStar(require("globby"));
const terser_1 = require("terser");
const ts_loader_1 = tslib_1.__importDefault(require("../webpack-loaders/ts-loader"));
const tsx_loader_1 = tslib_1.__importDefault(require("../webpack-loaders/tsx-loader"));
const jsx_loader_1 = tslib_1.__importDefault(require("../webpack-loaders/jsx-loader"));
const fx_models_1 = require("@omnia/fx-models");
const $ = tslib_1.__importStar(require("../variables"));
const shared_1 = require("../shared");
const tooling_1 = require("@omnia/tooling");
const MiniCssExtractPlugin = require('mini-css-extract-plugin');
const ConcatSource = require('webpack-core/lib/ConcatSource');
const CircularDependencyPlugin = require('circular-dependency-plugin');
const isEqual = require('lodash/isEqual');
let outDirManifestMetadata = "client/tooling/vue/output_manifests", _manifestsEntry = {}, _registeredReferenceManifests = [], serviceId = null, _modulesStats = {}, _manifestsStats = {}, keepTrackbuildOptions = {}, _transformResourcepaths = [], wcDomProps, _wcDefinitions = {};
if ($.isExtensionEnv) {
outDirManifestMetadata = "node_modules/@omnia/tooling-vue/internal-do-not-import-from-here/output_manifests";
}
tooling_1.core.registerCleanTask({
order: 2,
task: function () {
return new Promise(function (resolve, reject) {
clean()
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.AfterScanManifests,
order: 2,
task: function () {
return new Promise(function (resolve, reject) {
buildWebpackEntries()
.then(resolve, reject);
});
}
});
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.AfterScanManifests,
order: 2,
task: function () {
return new Promise(function (resolve, reject) {
// hard code to fix tiptap issue in omnia
if (!$.isExtensionEnv) {
fsExtra.removeSync("node_modules/tiptap-commands/node_modules");
fsExtra.removeSync("node_modules/tiptap-utils/node_modules");
}
buildWebpackEntries(true)
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.BeforeBundleManifest,
order: 2,
task: function (entries) {
return new Promise(function (resolve, reject) {
if (!entries || entries.length === 0) {
resolve(entries);
return;
}
beforeBundleManifest(entries)
.then(resolve, reject);
});
}
});
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.BeforeBundleManifest,
order: 2,
task: function (entries) {
return new Promise(function (resolve, reject) {
if (!entries || entries.length === 0) {
resolve(entries);
return;
}
beforeBundleManifest(entries)
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.BundleManifest,
order: 2,
task: function (entries) {
return new Promise(function (resolve, reject) {
if (!entries || entries.length === 0) {
resolve(entries);
return;
}
bundleManifest(entries)
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.AfterBundleManifest,
order: 2,
task: function (entries) {
return new Promise(function (resolve, reject) {
if (!entries || entries.length === 0) {
resolve(entries);
return;
}
afterBundleManifest(entries)
.then(resolve, reject);
});
}
});
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.AfterBundleManifest,
order: 2,
task: function (entries) {
return new Promise(function (resolve, reject) {
if (!entries || entries.length === 0) {
resolve(entries);
return;
}
afterBundleManifest(entries)
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.BeforeGenerateManifestsMetadata,
order: 2,
task: function (manifestInfo) {
return new Promise(function (resolve, reject) {
beforeGenerateManifestsMetadata(manifestInfo)
.then(resolve, reject);
});
}
});
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.BeforeGenerateManifestsMetadata,
order: 2,
task: function (manifestInfo) {
return new Promise(function (resolve, reject) {
beforeGenerateManifestsMetadata(manifestInfo, true)
.then(resolve, reject);
});
}
});
$.tooling.core.registerBuildTask({
stage: $.tooling.core.TaskStage.AfterGenerateManifestsMetadata,
order: 2,
task: function () {
return new Promise(function (resolve, reject) {
afterGenerateManifestsMetadata()
.then(resolve, reject);
});
}
});
$.tooling.core.registerServeTask({
stage: $.tooling.core.TaskStage.AfterGenerateManifestsMetadata,
order: 2,
task: function () {
return new Promise(function (resolve, reject) {
afterGenerateManifestsMetadata()
.then(resolve, reject);
});
}
});
function clean() {
return new Promise(function (resolve, reject) {
del_1.default.sync("node_modules/.cache");
del_1.default.sync($.tooling.utils.root(outDirManifestMetadata + "/manifest.entries.cached.json"));
if ($.isExtensionEnv) {
del_1.default.sync($.path.resolve(__dirname, "../wctypings.ts"));
}
else {
del_1.default.sync($.path.resolve(__dirname, `../bb000000-0000-bbbb-0000-0000000000bb.wctypings.ts`));
}
resolve();
});
}
function buildWebpackEntries(serve = false) {
return new Promise(function (resolve, reject) {
try {
var startTime = new Date().getTime();
var componentRegistry = $.composers.ComponentRegistry;
let componentRegistrations = componentRegistry.getRegistrations();
$.tooling.logTime("Found [" + componentRegistrations.length + "] component registrations", startTime);
var resourceRegistry = $.composers.ResourceRegistry;
let resourceBundlesWithBuildOptions = resourceRegistry.getRegisteredResourceBundles(shared_1.convertManifestPathToEntryPath);
$.tooling.logTime("Found [" + (resourceBundlesWithBuildOptions ? Object.keys(resourceBundlesWithBuildOptions).length : 0) + "] resource bundles", startTime);
let resourceEntries = {};
let wcDefinitionsPath, wcTypingsPath;
for (let key in resourceBundlesWithBuildOptions) {
let resource = resourceBundlesWithBuildOptions[key];
let manifest = $.composers.LoadableManifestRegistry.getRegisteredManifest(key);
if (!resource.buildOptions) {
resourceEntries[`${manifest.resourceName ? manifest.resourceName + "_" : ""}${key}`] = resource.paths;
}
else {
//Some special handling of buildoptions
console.log("debug " + key + " has build options for paths " + resource.paths + " buildoptions: " + JSON.stringify(resource.buildOptions));
}
}
//We only support typings for registered web components
wcDomProps = extractTypingsForComponents(componentRegistrations);
if (Object.keys(wcDomProps).length > 0) {
let wcDomPropsDesc = `Extracted web component typings for ${Object.keys(wcDomProps).length} component(s)`;
$.tooling.logTime(wcDomPropsDesc, startTime);
}
if ($.isExtensionEnv) {
wcDefinitionsPath = $.path.resolve(__dirname, "../wcdefinitions.json");
wcTypingsPath = $.path.resolve(__dirname, "../wctypings.ts");
}
else {
wcDefinitionsPath = $.path.resolve(__dirname, `../${getServiceId().toLowerCase()}.wcdefinitions.json`);
wcTypingsPath = $.path.resolve(__dirname, `../${getServiceId().toLowerCase()}.wctypings.ts`);
}
fsExtra.writeJsonSync(wcDefinitionsPath, wcDomProps);
let wcTypings = `import * as base from "vue-tsx-support/types/base";
//{{importWC}}
declare global {
namespace VueTsxSupport.JSX {
interface Element { }
interface ElementClass { }
interface IntrinsicElements {
//{{elementName}}
}
}
}
`;
if ($.isExtensionEnv) {
wcTypings = `import { VueComponentBaseProps } from "@omnia/fx/ux";
${wcTypings}`;
}
else {
wcTypings = `import { VueComponentBaseProps } from "../../../client/fx/ux/index";
${wcTypings}`;
}
componentRegistrations.forEach(wc => {
wcTypings = generateWebComponentTypings(wc, wcTypings);
});
fsExtra.outputFileSync(wcTypingsPath, wcTypings);
wcDomProps = $.merge(wcDomProps, getRegisteredWebComponentDefinitions());
let componentEntries = createVueEntryFormRegistrations(componentRegistrations);
var entries = $.merge(componentEntries, resourceEntries);
if (checkDuplicateWebpackEntryPoints(entries)) {
$.tooling.log('Build manifests metadata have error that found duplicated resource path', $.tooling.LogTypes.Error);
reject();
return;
}
let bundleOptions = getBuildOption().bundleOptions;
if (bundleOptions && bundleOptions.commonsChunk && Object.keys(entries).length > 0) {
const hmrEnabled = $.composers.getHosting().hmr;
if ((!serve || !hmrEnabled) && Object.keys(entries).find(key => key.indexOf(bundleOptions.commonsChunk.name.toString()) > -1) === undefined) {
var fakeFile = $.isExtensionEnv ? "./node_modules/@omnia/tooling-vue/internal-do-not-import-from-here/tasks/materials/empty.js" : "./client/tooling/vue/tasks/materials/empty.js";
$.composers.ManifestRegistry.setCurrentManifestPath("node_modules");
$.composers
.Composer
.registerManifest(new fx_models_1.Guid(bundleOptions.commonsChunk.name.toString()))
.registerResources({
resourcePaths: [fakeFile]
});
$.composers.ManifestRegistry.setCurrentManifestPath();
}
_manifestsEntry = entries;
resolve(entries);
}
else {
_manifestsEntry = entries;
resolve(entries);
}
}
catch (ex) {
console.dir(ex.stack);
reject();
}
});
}
function buildManifestMetadatas(entries) {
return new Promise(function (resolve, reject) {
try {
var startTime = new Date().getTime();
let outputDir = outDirManifestMetadata;
let bundleOptions = getBuildOption().bundleOptions;
_transformResourcepaths = [];
if (Object.keys(entries).length === 0) {
resolve(entries);
return;
}
if (bundleOptions && bundleOptions.commonsChunk) {
resolve(entries);
return;
}
$.tooling.log('Build manifests metadata running...', $.tooling.LogTypes.HeadLine);
let updateMetadataFiles = () => {
Object.keys(entries).forEach((entry) => {
let manifestPath = outputDir + "/" + entry + '.manifest.json';
if ($.fs.existsSync($.tooling.utils.root(manifestPath))) {
let manifestJson = $.tooling.core.loadFile(manifestPath);
Object.keys(manifestJson.content).forEach((key) => {
if (entries[entry].indexOf(key) === -1) {
manifestJson.content[key] = undefined;
}
});
delete require.cache[$.tooling.utils.root(manifestPath)];
$.fs.writeFileSync(manifestPath, JSON.stringify(manifestJson));
}
});
};
let webpackConfigs = [];
Object.keys(entries).forEach((id) => {
var entry = {};
entry[id] = entries[id];
var vueWebpackConfig = createWebpackConfigForManifestMetadata(entry, outputDir);
webpackConfigs.push(vueWebpackConfig);
});
let compiler = $.webpack(webpackConfigs);
compiler.run((err, stats) => {
updateMetadataFiles();
$.del.sync([outputDir + '/*.js']);
if (err) {
$.tooling.logTime(`Build manifests metadata have an exception`, startTime);
$.tooling.log(err.stack || err, $.tooling.LogTypes.Error);
reject();
//compiler.close((err, result) =>{})
return;
}
if (stats.hasErrors()) {
$.tooling.logTime(`Build manifests metadata have an exception`, startTime);
for (let stateError of stats.toJson({
assets: false,
hash: true
}).errors) {
$.tooling.log(stateError.stack || stateError, $.tooling.LogTypes.Error);
}
reject();
//compiler.close((err, result) => { })
return;
}
$.tooling.logTime('Build manifests metadata done', startTime);
compiler.close((err, result) => { });
resolve(entries);
});
}
catch (e) {
$.del.sync([outDirManifestMetadata + '/*.js']);
$.tooling.log('Build manifests metadata Exception: ' + e.message + ' stack trace: ', $.tooling.LogTypes.Error);
console.dir(e.stack);
reject();
}
});
}
function beforeBundleManifest(entries) {
return new Promise(function (resolve, reject) {
let bundleOptions = getBuildOption().bundleOptions;
if (bundleOptions && bundleOptions.commonsChunk && Object.keys(entries).length > 0) {
resolve(entries);
return;
}
else {
let isRunBuildMetadata = true;
let cachedEntriesPath = $.tooling.utils.root(outDirManifestMetadata + "/manifest.entries.cached.json");
// if (process.argv.length > 0 && process.argv.find(argv => argv === "--cache") !== undefined) {
// if ($.fs.existsSync(cachedEntriesPath)) {
// let cachedEntries = require(cachedEntriesPath);
// isRunBuildMetadata = !isEqual(entries, cachedEntries);
// }
// }
if ($.fs.existsSync(cachedEntriesPath)) {
let cachedEntries = require(cachedEntriesPath);
isRunBuildMetadata = !isEqual(entries, cachedEntries);
}
if (isRunBuildMetadata) {
let entriesToBuild = entries;
if (!getBuildOption().allowShareWCManifestBundle) {
let reourceRegistrationsKeys = Object.keys($.composers.ResourceRegistry.getResourceRegistrations());
entriesToBuild = {};
Object.keys(entries).forEach(entry => {
if (reourceRegistrationsKeys.find(rk => entry.indexOf(rk) > -1)) {
entriesToBuild[entry] = entries[entry];
}
});
}
buildManifestMetadatas(entriesToBuild).then(() => {
fsExtra.ensureFileSync(cachedEntriesPath);
fsExtra.writeJsonSync(cachedEntriesPath, entries);
resolve(entries);
});
}
else {
resolve(entries);
}
}
});
}
function bundleManifest(entries) {
var startTime = new Date().getTime();
return new Promise(function (resolve, reject) {
try {
// Hacky solution to delete node_modules inside tiptap regarding miss match version prosemirror
if (!$.isExtensionEnv) {
$.del.sync([
'node_modules/tiptap-commands/node_modules',
'node_modules/tiptap-extensions/node_modules',
'node_modules/tiptap-utils/node_modules'
]);
}
_transformResourcepaths = [];
_modulesStats = {};
var countEntry = Object.keys(entries).length;
if (countEntry === 0) {
resolve();
return;
}
let bundleOptions = getBuildOption().bundleOptions;
if (bundleOptions && bundleOptions.commonsChunk) {
var vueWebpackConfig = createVueWebpackConfig(null, entries, $.tooling.composer.OmniaOutput.OutputBundlePath);
$.webpack([vueWebpackConfig]).run((err, stats) => {
if (err) {
$.tooling.log('Bundle manifest error : \r\n', $.tooling.LogTypes.Error);
$.tooling.log(err.stack || err, $.tooling.LogTypes.Error);
reject();
return;
}
if (stats.hasErrors()) {
$.tooling.log('Bundle manifest error : \r\n', $.tooling.LogTypes.Error);
let errors = stats.toJson().errors;
errors.forEach((err) => {
$.tooling.log(err.stack || err, $.tooling.LogTypes.Error);
});
reject();
return;
}
resolve(entries);
});
}
else {
let webpackConfigs = [];
Object.keys(entries).forEach((id) => {
var entry = {};
entry[id] = entries[id];
var vueWebpackConfig = createVueWebpackConfig(entry, entries, $.tooling.composer.OmniaOutput.OutputBundlePath);
webpackConfigs.push(vueWebpackConfig);
});
let compiler = $.webpack(webpackConfigs);
compiler.run((err, stats) => {
if (checkDuplicateBundle()) { // detect duplicated bundle
$.tooling.log('Bundle manifest have error that found duplicated bundles', $.tooling.LogTypes.Error);
reject();
//compiler.close((err, result) => { })
return;
}
if (err) {
$.tooling.log('Bundle manifest error : \r\n', $.tooling.LogTypes.Error);
$.tooling.log(err.stack || err, $.tooling.LogTypes.Error);
reject();
//compiler.close((err, result) => { })
return;
}
if (stats.hasErrors()) {
$.tooling.log('Bundle manifest have error : \r\n', $.tooling.LogTypes.Error);
let errors = stats.toJson().errors;
errors.forEach((err) => {
$.tooling.log(err.stack || err, $.tooling.LogTypes.Error);
});
reject();
//compiler.close((err, result) => { })
return;
}
compiler.close((err, result) => { });
resolve(entries);
});
}
}
catch (e) {
$.tooling.log('Bundle-manifests Exception: ' + e.message + ' stack trace: ', $.tooling.LogTypes.Error);
console.dir(e.stack);
reject();
}
});
}
exports.bundleManifest = bundleManifest;
function afterBundleManifest(entries) {
return new Promise(function (resolve, reject) {
let startTime = new Date().getTime();
$.tooling.log('Creating combined manifests');
createCombinedManfests($.tooling.composer.OmniaOutput.OutputBundlePath).then(function () {
try {
$.tooling.logTime('Done - Creating combined manifests', startTime);
startTime = new Date().getTime();
$.tooling.log('Creating manifests hash', $.tooling.LogTypes.HeadLine);
processManifestGenerated(entries, $.tooling.composer.OmniaOutput.OutputBundlePath);
$.tooling.logTime('Done - Creating manifests hash', startTime);
resolve(entries);
}
catch (e) {
$.tooling.log(e, $.tooling.LogTypes.Error);
resolve();
}
}).catch(function (reason) {
$.tooling.log('Error creating group manifest bundles: ' + reason, $.tooling.LogTypes.Error);
resolve();
});
});
}
function beforeGenerateManifestsMetadata(manifestInfo, serve = false) {
return new Promise(function (resolve, reject) {
const hmrEnabled = $.composers.getHosting().hmr;
if (!serve || !hmrEnabled) {
ensureAddDependencyToCommonChunk(getServiceId(), manifestInfo.clientManifests);
}
resolve(manifestInfo);
});
}
function afterGenerateManifestsMetadata() {
return new Promise(function (resolve, reject) {
_transformResourcepaths = [];
importManifestsPackage()
.then(() => minifyBundles())
.then(resolve, reject);
});
}
function minifyBundles() {
return new Promise(function (resolve, reject) {
if (process.argv.length > 0 && process.argv.find(argv => argv === "--minify") !== undefined) {
let startTime = new Date().getTime();
$.tooling.log('Minify bundles running...');
const jsPaths = globby.sync([`${$.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)}/*.js`]);
let promises = [];
jsPaths.forEach(filePath => {
promises.push(new Promise(async (resolve, reject) => {
$.tooling.log(`Minify Js -> ${filePath}`);
let content = await fsExtra.readFile(filePath, 'utf8');
let minified = await (0, terser_1.minify)(content, {
sourceMap: false,
ecma: 5 // will remove es5 when not support IE 11
});
await fsExtra.writeFile(`${filePath.substring(0, filePath.length - 3)}.min.js`, minified.code, 'utf8');
$.tooling.log(`Minify Js Done -> ${filePath}`);
resolve();
}));
});
Promise.all(promises).then(() => {
$.tooling.logTime('Done - Minify Js bundles', startTime);
resolve();
});
//const debug = require('gulp-debug');
//const cleanCSS = require('gulp-clean-css');
//let processing = 2;
//let complete = () => {
// --processing;
// if (processing === 0) {
// resolve();
// }
//}
//$.gulp
// .src(`${$.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)}/*.js`)
// .pipe(debug({ title: 'Minify Js ->' }))
// .pipe(terser({
// ecma: 5 // will remove es5 when not support IE 11
// }))
// .pipe(rename(function (path) {
// path.basename += ".min";
// }))
// .pipe(debug({ title: 'Minify Js Done ->' }))
// .pipe($.gulp.dest($.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)))
// .on('end', () => {
// $.tooling.logTime('Done - Minify Js bundles', startTime);
// complete();
// })
//$.gulp.src(`${$.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)}/*.css`)
// .pipe(debug({ title: 'Minify Css ->' }))
// .pipe(cleanCSS())
// .pipe(rename(function (path) {
// path.basename += ".min";
// }))
// .pipe(debug({ title: 'Minify Css Done ->' }))
// .pipe($.gulp.dest($.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)))
// .on('end', () => {
// $.tooling.logTime('Done - Minify Css bundles', startTime);
// complete();
// })
}
else {
resolve();
}
});
}
function createVueWebpackConfig(currentEntry, entries, bundleOutputDir, hotModuleReload, viteHmrOption) {
let buildOption = getBuildOption() || {};
let isBundleCommonChunk = buildOption.bundleOptions && buildOption.bundleOptions.commonsChunk && buildOption.bundleOptions.commonsChunk.name;
const extractCss = new MiniCssExtractPlugin({
filename: "[name].css",
});
let entry = currentEntry || entries;
let referenceManifests = buildReferenceManifest(currentEntry, entries);
let plugins = [
new $.omniaWebpackPlugins.PreventInlineEntryModule(),
new $.webpack.DefinePlugin({
process: { env: { NODE_ENV: JSON.stringify('production') } }
}),
...referenceManifests,
extractCss,
new $.omniaWebpackPlugins.NamedModulesPlugin(buildModuleName()),
];
if (!buildOption.detectCircularDependencyOptions || buildOption.detectCircularDependencyOptions.disable !== true) {
plugins.unshift(new CircularDependencyPlugin({
// exclude detection of files based on a RegExp
exclude: buildOption.detectCircularDependencyOptions && buildOption.detectCircularDependencyOptions.exclude ?
buildOption.detectCircularDependencyOptions.exclude : /node_modules/,
// add errors to webpack instead of warnings
failOnError: true,
// set the current working directory for displaying module paths
cwd: process.cwd(),
onStart({ compilation }) {
//$.tooling.log('start detecting webpack modules cycles');
},
// `onDetected` is called for each module that is cyclical
onDetected({ module: webpackModuleRecord, paths, compilation }) {
// `paths` will be an Array of the relative module paths that make up the cycle
// `module` will be the module record generated by webpack that caused the cycle
compilation.errors.push(new Error(paths.join(' -> ')));
},
// `onEnd` is called before the cycle detection ends
onEnd({ compilation }) {
//$.tooling.log('end detecting webpack modules cycles');
}
}));
}
let modifyContent = [];
if (buildOption.bundleOptions && buildOption.bundleOptions.removeSourceMap) {
modifyContent.push({
pattern: /# sourceMappingURL=(.*\.map)/g,
replacement: '# $1'
});
}
if (isBundleCommonChunk) {
plugins = plugins.concat([
new $.omniaWebpackPlugins.BuildWebpackRequire(getServiceId(), "__webpack_require__", true)
]);
}
else {
if (modifyContent.length > 0) {
plugins.push(new $.omniaWebpackPlugins.ModifyContent(modifyContent));
}
if (buildOption.detectDuplicatedBundle !== false) {
plugins.push(new $.omniaWebpackPlugins.StatsWriterPlugin({
fields: ['modules', 'assetsByChunkName'],
transform(data, opts) {
// build manifets stats to detect duplicate bundle
let entryName = Object.keys(data.assetsByChunkName)[0];
_manifestsStats[entryName] = [];
data.modules.filter(m => typeof m.id === 'string'
&& m.id.trim().length > 0
&& m.id.indexOf('dll-reference') === -1
&& m.identifier.indexOf('from dll-reference') === -1).forEach(module => {
_manifestsStats[entryName].push(module.id);
_modulesStats[module.id] = _modulesStats[module.id] || new Set();
_modulesStats[module.id].add(entryName);
});
}
}));
}
plugins.push(new $.omniaWebpackPlugins.BuildWebpackRequire(getServiceId(), $.tooling.utils.getGuidValue(Object.keys(currentEntry)[0])));
}
plugins.push(new $.omniaWebpackPlugins.ChunkAssets(function (compilation, fileName) {
chunkAsset(entries, compilation, fileName, viteHmrOption);
}));
let webpackEntries = {};
Object.keys(entry).forEach(name => {
webpackEntries[name] = { import: entry[name] };
});
return {
mode: 'production',
devtool: false,
context: $.tooling.utils.root(""),
entry: entry,
optimization: Object.assign({
minimize: false,
usedExports: false,
providedExports: true,
removeAvailableModules: false,
mangleExports: false,
concatenateModules: true,
//moduleIds: 'natural' as any
}, isBundleCommonChunk && !viteHmrOption ? buildCommonChunk(entry) : {}),
resolve: {
modules: $.tooling.core.getWebpackResolveModules(),
extensions: ['.ts', '.tsx', '.js', '.jsx', '.html', '.vue', '.less', '.styl'],
symlinks: false,
cacheWithContext: true,
descriptionFiles: ['package.json'],
alias: Object.assign({}, $.tooling.core.getWebpackResolveAlias(), {
'tiptap$': 'tiptap/dist/tiptap.esm.js',
'tiptap-utils$': 'tiptap-utils/dist/utils.esm.js',
'tiptap-extensions$': 'tiptap-extensions/dist/extensions.esm.js',
'tiptap-commands$': 'tiptap-commands/dist/commands.esm.js',
'w3c-keyname$': $.path.resolve($.tooling.utils.root(""), 'node_modules/w3c-keyname/index.es.js'),
'axios$': 'axios/dist/axios.js',
'typestyle$': 'typestyle/lib.es2015/index.js',
'vue$': 'vue/dist/vue.esm.js',
'rope-sequence$': 'rope-sequence/dist/index.js',
'orderedmap$': 'orderedmap/index.js',
'@microsoft/signalr': '@microsoft/signalr/dist/webworker/signalr.js',
'@microsoft/teams-js': '@microsoft/teams-js/dist/umd/MicrosoftTeams.js',
"vue-tsx-support/enable-check": $.isExtensionEnv ? $.path.resolve($.tooling.utils.root(""), "node_modules/@omnia/tooling-vue/internal-do-not-import-from-here/tasks/materials//dummy-vue-tsx-support-enable-check.js") : $.path.resolve($.tooling.utils.root(""), "client/tooling/vue/tasks/materials/dummy-vue-tsx-support-enable-check.js")
}),
},
target: ['web', 'es2022'],
output: {
//library: {
// type: "umd"
//},
pathinfo: false,
path: $.tooling.utils.root(bundleOutputDir),
filename: '[name].js',
chunkLoadingGlobal: "omniaWebpackJsonp['" + getServiceId() + "']['__register_module__']",
hotUpdateGlobal: ("webpackHotUpdate_" + (isBundleCommonChunk ? getServiceId() : getServiceId() + $.tooling.utils.getGuidValue(Object.keys(currentEntry)[0]))).replace(/-/g, "")
},
module: {
noParse: buildOption.noParse || /wwwroot\\scripts(.*).js|wwwroot\/scripts(.*).js/,
rules: [
{
test: /\.m?js$/,
resolve: {
fullySpecified: false, // disable the behaviour
},
},
...(0, ts_loader_1.default)(getBuildOption().enableTreeShaking),
...(0, tsx_loader_1.default)(getBuildOption().enableTreeShaking, wcDomProps, hotModuleReload),
...(0, jsx_loader_1.default)(getBuildOption().enableTreeShaking, wcDomProps, hotModuleReload),
{
// remove vuetify locale
test: (path) => {
const pathInUnixStyle = path.replace(/\\/g, "/");
if (pathInUnixStyle.indexOf("/vuetify/lib/locale/") > -1
&& pathInUnixStyle.indexOf("/vuetify/lib/locale/index.js") === -1
&& pathInUnixStyle.indexOf("/vuetify/lib/locale/en.js") === -1) {
return true;
}
return false;
},
use: 'null-loader',
},
...($.isExtensionEnv ? [] : [{
test: /\.s(c|a)ss$/,
use: [
{
loader: MiniCssExtractPlugin.loader,
//options: {
// hmr: hotModuleReload,
//}
},
{
loader: 'css-loader',
options: {
sourceMap: false,
}
},
{
loader: 'postcss-loader',
options: {
postcssOptions: {
plugins: [
require('autoprefixer')({
//grid: 'autoplace'
}),
prefixCssSelector()
]
}
}
},
{
loader: 'sass-loader',
options: {
implementation: require('sass'),
sassOptions: {
//fiber: require('fibers'),
indentedSyntax: true,
sourceMap: false
}
//fiber: require('fibers')
}
}
]
}]),
{
test: /\.less$/,
use: [
{
loader: MiniCssExtractPlugin.loader,
},
{
loader: 'css-loader',
options: {
sourceMap: false,
}
},
{
loader: 'less-loader'
}
]
},
{
test: /\.css$/,
use: [
{
loader: MiniCssExtractPlugin.loader,
},
{
loader: 'css-loader',
options: {
sourceMap: false,
modules: false
}
}
]
},
{
test: /\.(woff2?|eot|ttf|otf|svg)(\?.*)?$/,
use: [{
loader: 'file-loader',
options: {
name: '[name]_[hash].[ext]',
outputPath: "../fonts/",
publicPath: '/omnia/fonts/',
esModule: false
}
}]
},
{
test: /\.(ico|gif|png|jpe?g|svg)$/i,
use: [{
loader: 'file-loader',
options: {
name: '[name].[ext]',
outputPath: "../images/",
publicPath: '/omnia/images/',
esModule: false
}
}]
}
]
},
plugins: plugins
};
}
exports.createVueWebpackConfig = createVueWebpackConfig;
function createWebpackConfigForManifestMetadata(entry, metadataOutputDir) {
var entensionId = getServiceId();
return Object.assign({}, (0, shared_1.getBaseWebpackConfigForManifestMetadata)(entry, metadataOutputDir, wcDomProps, getBuildOption().enableTreeShaking), {
plugins: [
...buildReferenceManifestFromConfig(),
new $.omniaWebpackPlugins.NamedModulesPlugin(buildModuleName()),
new $.webpack.DllPlugin({
entryOnly: false,
path: $.path.join($.tooling.utils.root(""), metadataOutputDir, '[name].manifest.json'),
name: `omniaWebpackJsonp['${entensionId}']['${$.tooling.utils.getGuidValue(Object.keys(entry)[0])}']`
})
]
});
}
function buildCommonChunk(entry) {
let bundleOptions = getBuildOption().bundleOptions;
let minChunk = bundleOptions.commonsChunk.minChunks || 2;
let name = bundleOptions.commonsChunk.name.toString();
Object.keys(entry).forEach(key => {
if (key.indexOf(bundleOptions.commonsChunk.name.toString()) > -1) {
name = key;
return;
}
});
return {
runtimeChunk: {
name: entrypoint => name
},
splitChunks: {
chunks: 'all',
cacheGroups: {
common: {
name: name,
minChunks: minChunk,
chunks: "all",
enforce: true
},
vendors: {
test: /[\\/]node_modules[\\/]/,
name: name,
chunks: 'all'
}
}
}
};
}
function processManifestGenerated(entries, outDir) {
var allowJsOutputExtensions = [".js", ".ts", ".tsx", ".jsx", ".vue"];
if (entries) {
var manifestsPaths = globby.sync(outDir.replace(/\/$/, '') + '/*.*', {});
if (manifestsPaths) {
for (let p of manifestsPaths) {
var manifestId = $.tooling.utils.getGuidValue($.tooling.utils.getFileName(p));
if (manifestId) {
var entryPaths = entries[$.tooling.utils.getFileName(p)];
if (entryPaths &&
$.path.extname(p) === ".js" &&
!allowOutputJs(entryPaths)) {
$.del.sync(p);
}
else {
updateLoadableManifest(manifestId, p);
}
}
}
}
}
function updateLoadableManifest(manifestId, filePath) {
var manifestInfo = $.composers.LoadableManifestRegistry.getRegisteredManifest(manifestId);
if (manifestInfo != null) {
var hash = $.md5File.sync(filePath);
if ($.path.extname(filePath) === ".js") {
$.composers.LoadableManifestRegistry.addManifestVersion(manifestId, $.enums.BundleTargetTypes.Javascript, hash);
$.composers.LoadableManifestRegistry.addManifestBundleType(manifestId, $.enums.BundleTargetTypes.Javascript);
}
else if ($.path.extname(filePath) === ".css") {
$.composers.LoadableManifestRegistry.addManifestVersion(manifestId, $.enums.BundleTargetTypes.Stylesheet, hash);
$.composers.LoadableManifestRegistry.addManifestBundleType(manifestId, $.enums.BundleTargetTypes.Stylesheet);
}
}
}
function allowOutputJs(entryPaths) {
var allow = false;
if (entryPaths) {
for (let p of entryPaths) {
if (allowJsOutputExtensions.indexOf($.path.extname(p)) > -1) {
allow = true;
break;
}
}
}
else {
return true;
}
return allow;
}
}
exports.processManifestGenerated = processManifestGenerated;
function createCombinedManfests(outputDir) {
return new Promise(function (resolve, reject) {
var manifestGroupRegistry = $.composers.ManifestGroupRegistry;
let omniaServiceId = getServiceId();
let groupRegistrations = manifestGroupRegistry.getRegistrations();
if (groupRegistrations.length > 0) {
$.tooling.log("Found [" + groupRegistrations.length + "] group manifests", $.tooling.LogTypes.HeadLine);
let allPromises = [];
for (let reg of groupRegistrations) {
allPromises.push(createCombinedManfest(omniaServiceId, reg.manifestIdsInGroup, reg.resourceId, reg.resourceName, outputDir));
}
Promise.all(allPromises).then((result) => resolve()).catch(reject);
}
else {
resolve();
}
});
}
function createCombinedManfest(omniaServiceId, manifestIds, targetManifestId, targetManifestName, outputDir) {
return new Promise(function (resolve, reject) {
if (manifestIds &&
targetManifestId &&
manifestIds.length > 0) {
let manifestIdToFileNameMap = {};
let targetFileName = `${targetManifestName ? targetManifestName + "_" : ""}${targetManifestId}.js`;
manifestIdToFileNameMap[targetManifestId] = targetFileName;
$.tooling.log("Creating manifest group bundle [" + targetManifestId + "]", $.tooling.LogTypes.HeadLine);
let omniaServiceId = getServiceId();
manifestIds.sort((manifestId1, manifestId2) => {
var result = 0;
if ($.composers.LoadableManifestRegistry
.getManifestDependencies(manifestId1, omniaServiceId)
.find(d => d.resourceId === manifestId2 && d.omniaServiceId === omniaServiceId) !== undefined) {
result = 1;
}
else if ($.composers.LoadableManifestRegistry
.getManifestDependencies(manifestId2, omniaServiceId)
.find(d => d.resourceId === manifestId1 && d.omniaServiceId === omniaServiceId) !== undefined) {
result = -1;
}
return result;
});
let bundleNames = [];
for (let i = 0; i < manifestIds.length; i++) {
let manifest = $.composers.LoadableManifestRegistry.getRegisteredManifest(manifestIds[i]);
bundleNames[i] = outputDir + `/${manifest.resourceName ? manifest.resourceName + "_" : ""}${manifest.resourceId}.js`;
if (!$.fs.existsSync(bundleNames[i])) {
throw new Error("Error, can't create combined bundle: " + targetFileName + " can't find bundle to include: " + bundleNames[i]);
}
manifestIdToFileNameMap[manifestIds[i]] = bundleNames[i];
$.tooling.log("Adding manifest bundle [" + manifestIds[i] + "] to group", $.tooling.LogTypes.Info);
}
let mergedContent = "";
bundleNames.forEach(filePath => {
let manifestId = "";
let currentFilename = $.path.basename(filePath);
for (let id in manifestIdToFileNameMap) {
if (manifestIdToFileNameMap[id].endsWith(currentFilename)) {
manifestId = id;
break;
}
}
if (manifestId === "") {
throw Error("Couldn't extract manifest id from filename: " + currentFilename);
}
let content = fsExtra.readFileSync(filePath, 'utf8');
mergedContent = `
${mergedContent}
/* Start of resource:${manifestId} */omniaWebpackJsonp["bb000000-0000-bbbb-0000-0000000000bb"]["${fx_models_1.OmniaResourceManifests.FxCore.toString()}"]("06e712d2-9897-4891-9353-148547efe61c").ManifestResourceLoader.registerWebComponentFromGroupBundle("${omniaServiceId}", "${manifestId}", "${targetManifestId}", function(){
${content}
})//End of resource:${manifestId} `;
});
fsExtra.writeFileSync(`${outputDir}/${targetFileName}`, `/******/ if (typeof omniaLoader === 'undefined') {
/******/ globalThis['omniaLoader'] = {};
/******/ }
/******/ omniaLoader['${omniaServiceId}'] = omniaLoader['${omniaServiceId}'] || {};
/******/ if (omniaLoader['${omniaServiceId}']['${targetManifestId}']) {
/******/ throw new Error("Error, already loaded manifest ${targetManifestId} with service id ${omniaServiceId}");
/******/
}
/******/ omniaLoader['${omniaServiceId}']['${targetManifestId}'] = function () {
${mergedContent}
}
${$.composers.LoadableManifestRegistry.isDefineWithNoDependency(targetManifestId) ? `omniaLoader['${omniaServiceId}']['${targetManifestId}']()` : ''}`, 'utf8');
$.tooling.log("Done - Creating manifest group bundle for manifest id: " + targetManifestId, $.tooling.LogTypes.HeadLine);
resolve();
}
else {
//Nothing to create
resolve();
}
});
}
exports.createCombinedManfest = createCombinedManfest;
function importManifestsPackage() {
return new Promise(function (resolve, reject) {
if (process.argv.length > 0 && process.argv.find(argv => argv === "--no-import") !== undefined) {
resolve();
}
else {
let packagePaths = $.composers.ImportManifestRegistry.getPaths();
if (packagePaths && packagePaths.length > 0) {
$.tooling.log('Importing manifests package', $.tooling.LogTypes.HeadLine);
let startTime = new Date().getTime();
let processing = packagePaths.length;
packagePaths.forEach(packagePath => {
if ((!$.fs.existsSync($.tooling.utils.root(packagePath)) && !$.fs.existsSync(packagePath))) {
throw new Error(`Error, Not exist path ${packagePath}`);
}
else {
fsExtra.copy(packagePath, $.tooling.composer.OmniaOutput.OutputDir, {
//overwrite: false,
//errorOnExist:true
}, err => {
if (err) {
throw new Error(`Error, importing maniafest with path ${packagePath} : ${err}`);
}
--processing;
if (processing === 0) {
// check override manifets configurations
let configs = $.composers.ConfigurationClientServiceRegistry.getConfigurations();
Object.keys(configs).forEach(serviceId => {
if (serviceId.toLowerCase() !== getServiceId()) {
let manifestFilePath = $.tooling.utils.root("").replace(/\\/g, "/") + `/${$.tooling.composer.OmniaOutput.ManifestOutputPath}/${serviceId}_manifests.json`;
let manifestJsonObject = JSON.parse($.fs.readFileSync(manifestFilePath, 'utf8'));
manifestJsonObject.configuration = [configs[serviceId]['configuration']];
$.fs.writeFileSync(manifestFilePath, JSON.stringify(manifestJsonObject));