@omnia/tooling-composers
Version:
Provide tooling to work with manifest things.
471 lines (470 loc) • 20.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.BuildStage = exports.OmniaOutput = exports.buildLocalizationFiles = exports.bundleManifestsByWebpackEntries = exports.build = exports.buildManifestEntries = exports.processManifests = exports.getManifestsPaths = exports.scanManifests = exports.updateManifestData = exports.getManifestData = exports.getManifestById = exports.getServiceId = void 0;
const tslib_1 = require("tslib");
const globby = tslib_1.__importStar(require("globby"));
const fs_1 = tslib_1.__importDefault(require("fs"));
var del = require('del'), fsExtra = require('fs-extra');
var serviceId = null;
var cleanOutput = true;
var isOmniaEnv = !fs_1.default.existsSync(process.cwd() + "/node_modules/@omnia/tooling-vue/package.json");
const tooling_1 = require("@omnia/tooling");
const composers = tslib_1.__importStar(require("./index"));
const index_1 = require("./models/index");
const DevelopmentBuildConfiguration_1 = require("./DevelopmentBuildConfiguration");
const ServiceManifestRegistry_1 = require("./ServiceManifestRegistry");
const BuildStage = {
BeforeScanManifests: "BeforeScanManifests",
AfterScanManifests: "AfterScanManifests",
BeforeBundleManifest: "BeforeBundleManifest",
BundleManifest: "BundleManifest",
AfterBundleManifest: "AfterBundleManifest",
BeforeGenerateManifestsMetadata: "BeforeGenerateManifestsMetadata",
GenerateManifestsMetadata: "GenerateManifestsMetadata",
AfterGenerateManifestsMetadata: "AfterGenerateManifestsMetadata"
};
exports.BuildStage = BuildStage;
const ServeStage = {
BeforeScanManifests: "BeforeScanManifests",
AfterScanManifests: "AfterScanManifests",
CreateServer: "CreateServer",
AfterCreateServer: "AfterBundleManifest",
};
let _manifestJsonObject = null;
let _manifestDict = null;
let _outputLocalizationPath = "{{rootFolder}}omnia/dist/localizations";
let _manifestOutputPath = "{{rootFolder}}omnia/dist/manifests";
let _outputBundlePath = "{{rootFolder}}omnia/dist/bundles";
let _outputFontPath = "{{rootFolder}}omnia/dist/fonts";
let _outputImagePath = "{{rootFolder}}omnia/dist/images";
let _outputDir = "{{rootFolder}}omnia/dist";
let startProcessTime;
let isServing = false;
tooling_1.core.registerBuildTask({ stage: tooling_1.core.TaskStage.Build, order: 10, task: build });
tooling_1.core.registerServeTask({ stage: tooling_1.core.TaskStage.BeforeCreateServer, order: 1, task: beforeCreateServer });
tooling_1.core.registerServeTask({ stage: tooling_1.core.TaskStage.AfterCreateServer, order: 1, task: serve });
class OmniaOutput {
static get OutputLocalizationPath() {
return _outputLocalizationPath.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
static get ManifestOutputPath() {
return _manifestOutputPath.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
static get OutputBundlePath() {
return _outputBundlePath.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
static get OutputFontPath() {
return _outputFontPath.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
static get OutputImagePath() {
return _outputImagePath.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
static get OutputDir() {
return _outputDir.replace("{{rootFolder}}", getOutDir(this.rootFolder));
}
}
exports.OmniaOutput = OmniaOutput;
OmniaOutput.rootFolder = "wwwroot"; // set default web app root folder
function getOutDir(defaultDir) {
const buildOptions = composers.BuildConfigurationRegistry.getBuildOptions();
return tooling_1.utils.ensureTraillingSlash(buildOptions?.outDir || defaultDir);
}
function buildManifestEntries(scanFolders, cleanOutputBeforeBuild) {
cleanOutput = cleanOutputBeforeBuild === false ? false : true;
return new Promise(function (resolve, reject) {
try {
startProcessTime = new Date().getTime();
scanManifestsPromise(scanFolders)
.then(afterScanManifest, reject)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
catch (err) {
reject(err);
}
});
}
exports.buildManifestEntries = buildManifestEntries;
function beforeCreateServer() {
return new Promise((resolve, reject) => {
isServing = true;
executeServiceManifest();
executeRegisteredTasks(tooling_1.core.TaskStage.CreateServer, null, resolve, reject);
});
}
function serve(server) {
isServing = true;
cleanOutput = false;
const hmrEnabled = composers.getHosting().hmr;
return new Promise(function (resolve, reject) {
try {
startProcessTime = new Date().getTime();
scanManifestsPromise()
.then(() => {
if (hmrEnabled) {
afterScanManifest()
//.then(beforeBundleManifest, chainError)
//.then(bundleManifest, chainError)
.then(beforeGenerateManifestsMetadata, chainError)
.then(generateManifestsMetadata, chainError)
.then(afterGeneratedManifestsMetadata, chainError)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
else {
afterScanManifest()
.then(beforeBundleManifest, chainError)
.then(bundleManifest, chainError)
.then(afterBundleManifest, chainError)
.then(beforeGenerateManifestsMetadata, chainError)
.then(generateManifestsMetadata, chainError)
.then(afterGeneratedManifestsMetadata, chainError)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
}, reject)
.catch((err) => {
reject(err);
});
}
catch (err) {
resolve();
}
});
}
function build(scanFolders, cleanOutputBeforeBuild) {
return new Promise(function (resolve, reject) {
try {
startProcessTime = new Date().getTime();
scanManifestsPromise(scanFolders)
.then(() => {
if (!DevelopmentBuildConfiguration_1.DevelopmentBuildConfiguration.isEnableBuild) {
resolve();
}
else if (process.argv.length > 0
&& process.argv.find(argv => argv === "--manifestOnly") !== undefined
&& (process.argv.find(argv => argv === "--force") !== undefined
|| fs_1.default.existsSync(`${OmniaOutput.ManifestOutputPath}/${getServiceId()}_manifests.json`))) {
cleanOutput = false;
beforeGenerateManifestsMetadata(null, true)
.then(generateManifestsMetadata, chainError)
.then(afterGeneratedManifestsMetadata, chainError)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
else {
afterScanManifest()
.then(beforeBundleManifest, chainError)
.then(bundleManifest, chainError)
.then(afterBundleManifest, chainError)
.then(beforeGenerateManifestsMetadata, chainError)
.then(generateManifestsMetadata, chainError)
.then(afterGeneratedManifestsMetadata, chainError)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
}, reject)
.catch((err) => {
reject(err);
});
}
catch (err) {
resolve();
}
});
}
exports.build = build;
function bundleManifestsByWebpackEntries(entries) {
return new Promise(function (resolve, reject) {
try {
beforeBundleManifest(entries)
.then(bundleManifest, chainError)
.then(afterBundleManifest, chainError)
.then(beforeGenerateManifestsMetadata, chainError)
.then(generateManifestsMetadata, chainError)
.then(afterGeneratedManifestsMetadata, chainError)
.then(resolve, reject)
.catch((err) => {
reject(err);
});
}
catch (err) {
reject(err);
}
});
}
exports.bundleManifestsByWebpackEntries = bundleManifestsByWebpackEntries;
function scanManifestsPromise(scanFolders) {
return new Promise(function (resolve, reject) {
try {
scanManifests(scanFolders);
resolve();
}
catch (ex) {
if (reject)
reject(ex);
}
});
}
function executeServiceManifest() {
if (fs_1.default.existsSync(tooling_1.utils.root("omnia.service.ts"))) {
composers.ManifestRegistry.setCurrentManifestPath("omnia.service.ts");
delete require.cache[tooling_1.utils.root("omnia.service.ts")];
require(tooling_1.utils.root("omnia.service.ts"));
}
if (fs_1.default.existsSync(tooling_1.utils.root("omnia.service.local.ts"))) {
composers.ManifestRegistry.setCurrentManifestPath("omnia.service.local.ts");
delete require.cache[tooling_1.utils.root("omnia.service.local.ts")];
require(tooling_1.utils.root("omnia.service.local.ts"));
}
}
function scanManifests(scanFolders) {
const startTime = new Date().getTime();
tooling_1.utils.logTime('Scan manifests running...', startTime);
_manifestDict = null;
_manifestJsonObject = null;
let scanPattern = ["**"];
let searchOptions = { ignore: '**/node_modules/**' };
composers.ManifestRegistry.clearState(); // ensure clean state
executeServiceManifest();
const buildOptions = composers.BuildConfigurationRegistry.getBuildOptions();
if (buildOptions && buildOptions.include) {
scanPattern = buildOptions.include;
searchOptions = {};
}
var manifests = getManifestsPaths(scanFolders || scanPattern, searchOptions);
processManifests(manifests);
tooling_1.utils.logTime('Scan manifest finished', startTime);
}
exports.scanManifests = scanManifests;
function afterScanManifest() {
return new Promise(function (resolve, reject) {
if (composers.ServiceManifestRegistry.getServiceInfo().serviceType === index_1.ServiceTypes.WebApp) {
OmniaOutput.rootFolder = "wwwroot";
}
else if (composers.ServiceManifestRegistry.getServiceInfo().serviceType === index_1.ServiceTypes.Worker) {
OmniaOutput.rootFolder = "approot";
// delete approot folder before build
del.sync(["approot"]);
}
executeRegisteredTasks(tooling_1.core.TaskStage.AfterScanManifests, null, resolve, reject);
});
}
function beforeBundleManifest(data) {
return new Promise(function (resolve, reject) {
ensureFolder(OmniaOutput.OutputBundlePath);
if (cleanOutput) {
del.sync([OmniaOutput.OutputBundlePath + '/**', '!' + OmniaOutput.OutputBundlePath]);
}
executeRegisteredTasks(tooling_1.core.TaskStage.BeforeBundleManifest, data, resolve, reject);
});
}
function bundleManifest(data) {
return new Promise(function (resolve, reject) {
let startTime = new Date().getTime();
tooling_1.utils.log('Bundle manifests running...', tooling_1.utils.LogTypes.HeadLine);
executeRegisteredTasks(tooling_1.core.TaskStage.BundleManifest, data, (data) => {
tooling_1.utils.logTime('Bundle manifests done', startTime);
resolve(data);
}, reject);
});
}
function afterBundleManifest(entries) {
return new Promise(function (resolve, reject) {
executeRegisteredTasks(tooling_1.core.TaskStage.AfterBundleManifest, entries, resolve, reject);
});
}
function beforeGenerateManifestsMetadata(entries, outputServiceManifestOnly = false) {
return new Promise(function (resolve, reject) {
try {
tooling_1.utils.log('Creating manifests', tooling_1.utils.LogTypes.HeadLine);
let clientManifests = outputServiceManifestOnly ? null : composers.ManifestRegistry.getClientManifests(getServiceId());
let serverManifests = composers.ManifestRegistry.getServerManifests(getServiceId());
executeRegisteredTasks(tooling_1.core.TaskStage.BeforeGenerateManifestsMetadata, { clientManifests: clientManifests, serverManifests: serverManifests, entries: entries }, resolve, reject);
}
catch (err) {
reject(err);
}
});
}
function generateManifestsMetadata(data) {
return new Promise(function (resolve, reject) {
try {
var startTime = new Date().getTime();
if (!isOmniaEnv && cleanOutput) {
del.sync([OmniaOutput.ManifestOutputPath + '/**', '!' + OmniaOutput.ManifestOutputPath]);
}
ensureFolder(OmniaOutput.ManifestOutputPath);
if (data.clientManifests) {
tooling_1.utils.log("Create manifests.json");
fs_1.default.writeFileSync(OmniaOutput.ManifestOutputPath + `/${getServiceId()}_manifests.json`, JSON.stringify(data.clientManifests));
tooling_1.utils.logTime("Done - Creating client side manifests", startTime);
}
startTime = new Date().getTime();
tooling_1.utils.log('Creating server side manifests', tooling_1.utils.LogTypes.HeadLine);
tooling_1.utils.log("Creating extension-manifest.json");
fs_1.default.writeFileSync(OmniaOutput.ManifestOutputPath + `/${getServiceId()}_servicemanifest.json`, JSON.stringify(data.serverManifests));
tooling_1.utils.logTime('Done - Creating server side manifests', startTime);
startTime = new Date().getTime();
tooling_1.utils.log('Building localization files', tooling_1.utils.LogTypes.HeadLine);
ensureFolder(OmniaOutput.OutputLocalizationPath);
if (!isOmniaEnv && cleanOutput) {
del.sync([OmniaOutput.OutputLocalizationPath + '/**', '!' + OmniaOutput.OutputLocalizationPath]);
}
buildLocalizationFiles();
tooling_1.utils.logTime('Done - Building localization file', startTime);
resolve(data);
}
catch (ex) {
if (reject)
reject(ex);
}
});
}
function afterGeneratedManifestsMetadata(data) {
return new Promise(function (resolve, reject) {
executeRegisteredTasks(tooling_1.core.TaskStage.AfterGenerateManifestsMetadata, null, () => {
tooling_1.utils.log(`See generated files in: ${getOutDir(OmniaOutput.rootFolder)}omnia/dist/...`);
tooling_1.utils.logTime('All done..', startProcessTime);
resolve(data);
}, reject);
});
}
function executeRegisteredTasks(stage, paras, resolve, reject) {
var tasks = isServing ? tooling_1.core.getRegisteredServeTasks() : tooling_1.core.getRegisteredBuildTasks();
tasks = tasks.filter(function (task) { return task.stage === stage; }).sort(sortTask) || [];
executeTasks(tasks, paras, resolve, reject);
}
function sortTask(task1, task2) {
return task1.order - task2.order;
}
function executeTasks(tasks, paras, resolve, reject) {
if (tasks.length === 0) {
if (resolve)
resolve(paras);
}
else {
tasks.shift()
.task(paras)
.then(function (data) { executeTasks(tasks, data, resolve, reject); }, (error) => {
if (reject)
reject(error);
})
.catch((error) => {
if (reject)
reject(error);
});
}
}
function getManifestsPaths(urlsToSearch, options) {
let manifestsPaths = [];
let searchPatterns = [];
let pattern;
for (let basePath of urlsToSearch) {
pattern = basePath.replace(/\/$/, '');
if (pattern.indexOf('manifest.ts') === -1) {
pattern = pattern + '/**/*manifest.ts';
}
searchPatterns.push(pattern);
}
manifestsPaths = globby.sync(searchPatterns, options);
return manifestsPaths;
}
exports.getManifestsPaths = getManifestsPaths;
function processManifests(manifestPaths) {
for (let p of manifestPaths) {
composers.ManifestRegistry.setCurrentManifestPath(p);
//ts-node will compile and execute the manifest ts, and component will reister in CompositionRegistry
try {
require(tooling_1.utils.root(p));
}
catch (e) {
tooling_1.utils.log('Processing manifest - ' + p, tooling_1.utils.LogTypes.Error);
console.log(e);
Object.keys(require.cache).forEach((id) => {
if (/\manifest.ts$/.test(id)) {
delete require.cache[id];
}
});
throw e;
}
composers.ManifestRegistry.setCurrentManifestPath();
}
//We need to delete the require cache for *.manifest.ts
//or else the code will be cached the next time this runs
Object.keys(require.cache).forEach((id) => {
if (/\manifest.ts$/.test(id)) {
delete require.cache[id];
}
});
}
exports.processManifests = processManifests;
function buildLocalizationFiles() {
var localizeObject = composers.getLocalizations();
Object.keys(localizeObject).forEach((key) => {
var destination = OmniaOutput.OutputLocalizationPath + `/${getServiceId()}_localized.loc.` + key + ".json";
destination = destination.replace("..", ".");
fsExtra.removeSync(destination);
fsExtra.writeJsonSync(destination, localizeObject[key]);
});
}
exports.buildLocalizationFiles = buildLocalizationFiles;
function getBuildOption() {
return composers.BuildConfigurationRegistry.getBuildOptions();
}
function getServiceId() {
var serviceInfo = composers.ServiceManifestRegistry.getServiceInfo();
if (serviceInfo === null) {
if (serviceId === null)
throw new Error("A service has not been registered, please use Composer.registerManifest(serviceId,serviceName).asWorker or .asWebApp)");
return serviceId;
}
serviceId = serviceInfo.id.toLowerCase();
return serviceId;
}
exports.getServiceId = getServiceId;
function ensureFolder(folderPath) {
if (!fs_1.default.existsSync(folderPath)) {
fsExtra.ensureDirSync(folderPath);
}
}
function chainError(err) {
return Promise.reject(err);
}
function getManifestData() {
if (!_manifestJsonObject) {
let manifestFilePath = tooling_1.utils.root("").replace(/\\/g, "/") + `/${OmniaOutput.ManifestOutputPath}/${ServiceManifestRegistry_1.ServiceManifestRegistry.getServiceInfo().id.toLowerCase()}_manifests.json`;
_manifestJsonObject = JSON.parse(fs_1.default.readFileSync(manifestFilePath, 'utf8'));
}
return _manifestJsonObject;
}
exports.getManifestData = getManifestData;
function updateManifestData(manifest) {
let manifestFilePath = tooling_1.utils.root("").replace(/\\/g, "/") + `/${OmniaOutput.ManifestOutputPath}/${ServiceManifestRegistry_1.ServiceManifestRegistry.getServiceInfo().id.toLowerCase()}_manifests.json`;
fsExtra.writeJsonSync(manifestFilePath, manifest);
_manifestJsonObject = null;
_manifestDict = null;
}
exports.updateManifestData = updateManifestData;
function getManifestById(id) {
if (!_manifestDict) {
_manifestDict = {};
let manifests = getManifestData();
if (manifests) {
[].concat(manifests.resource || []).concat(manifests.webcomponent || []).concat(manifests.groupedResouresAndComponents || [])
.forEach((m) => _manifestDict[m.resourceId.toString()] = m);
}
}
return _manifestDict[id.toString()];
}
exports.getManifestById = getManifestById;