@omnia/tooling-composers 8.0.112-vnext → 8.0.113-dev

package/internal-do-not-import-from-here/BlockingRegistry.js

@@ -18,6 +18,7 @@ class BlockInformation {
 //}
 class BlockingRegistry {
 }
+exports.BlockingRegistry = BlockingRegistry;
 BlockingRegistry.BlockedManifests = [];
 BlockingRegistry.addBlockedManifest = (omniaServiceId, manifestId) => {
     omniaServiceId = Utils_1.Utils.ensureValidServiceId(omniaServiceId);
@@ -51,4 +52,3 @@ BlockingRegistry.clearState = () => {
     BlockingRegistry.BlockedManifests = [];
 };
 BlockingRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BlockingRegistry.getClientManifests, BlockingRegistry.clearState));
-exports.BlockingRegistry = BlockingRegistry;

package/internal-do-not-import-from-here/BuildConfigurationRegistry.js

@@ -4,6 +4,7 @@ exports.BuildConfigurationRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class BuildConfigurationRegistry {
 }
+exports.BuildConfigurationRegistry = BuildConfigurationRegistry;
 BuildConfigurationRegistry.BuildOptions = null;
 BuildConfigurationRegistry.AddBuildOptions = (buildOptions) => {
     BuildConfigurationRegistry.BuildOptions = buildOptions;
@@ -23,4 +24,3 @@ BuildConfigurationRegistry.clearState = () => {
     BuildConfigurationRegistry.BuildOptions = null;
 };
 BuildConfigurationRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BuildConfigurationRegistry.getClientManifests, BuildConfigurationRegistry.clearState));
-exports.BuildConfigurationRegistry = BuildConfigurationRegistry;

package/internal-do-not-import-from-here/ComponentComposer.js

@@ -54,7 +54,7 @@ class ComponentComposer extends ComposerBase_1.ComposerBase {
             this.manifest.resourceName = manifestName;
         }
         if (this.manifest.target === undefined) {
-            this.manifest.target = models_1.ClientManifestTargetTypes.Public;
+            this.manifest.target = models_1.ClientManifestTargetTypes.public;
         }
     }
 }

package/internal-do-not-import-from-here/ComponentRegistry.js

@@ -72,6 +72,7 @@ class ComponentRegistry {
         };
     }
 }
+exports.ComponentRegistry = ComponentRegistry;
 ComponentRegistry.ComponentRegistrations = new Map();
 ComponentRegistry.ComponentElements = {};
 ComponentRegistry.registerComponent = (manifest, componentOptions) => {
@@ -159,4 +160,3 @@ ComponentRegistry.ensureCorrectManifest = (manifest) => {
     }
     manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
 };
-exports.ComponentRegistry = ComponentRegistry;

package/internal-do-not-import-from-here/Composer.js

@@ -63,6 +63,7 @@ class Composer {
         return new BlockingComposer_1.BlockingComposer();
     }
 }
+exports.Composer = Composer;
 /**
 * Registers a new manifest
 * @param manifestId the unique id of the manifest, must be a valid guid.
@@ -93,4 +94,3 @@ Composer.importManifests = (folderPath) => {
         }
     };
 };
-exports.Composer = Composer;

package/internal-do-not-import-from-here/ConfigurationClientServiceRegistry.js

@@ -68,6 +68,7 @@ class ConfigurationClientServiceRegistry {
         return ConfigurationClientServiceRegistry.configurations;
     }
 }
+exports.ConfigurationClientServiceRegistry = ConfigurationClientServiceRegistry;
 ConfigurationClientServiceRegistry.configurations = {};
 ConfigurationClientServiceRegistry.getClientManifests = (currentServiceId) => {
     let result = new Array();
@@ -83,4 +84,3 @@ ConfigurationClientServiceRegistry.clearState = () => {
     ConfigurationClientServiceRegistry.configurations = {};
 };
 ConfigurationClientServiceRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ConfigurationClientServiceRegistry.getClientManifests, ConfigurationClientServiceRegistry.clearState));
-exports.ConfigurationClientServiceRegistry = ConfigurationClientServiceRegistry;

package/internal-do-not-import-from-here/CustomServiceComposer.js

@@ -24,7 +24,7 @@ class CustomServiceComposer extends ServiceManifestComposer_1.ServiceManifestCom
         ServiceManifestRegistry_1.ServiceManifestRegistry.AddService(serviceInfo);
     }
     runHelm(cmd) {
-        ServiceManifestRegistry_1.ServiceManifestRegistry.getServiceInfo().hemlCommand = cmd;
+        ServiceManifestRegistry_1.ServiceManifestRegistry.getServiceInfo().helmCommand = cmd;
         return this;
     }
 }

package/internal-do-not-import-from-here/DevelopmentBuildConfiguration.js

@@ -26,6 +26,7 @@ class DevelopmentBuildConfiguration {
         return DevelopmentBuildConfiguration._enableMeasureBuild;
     }
 }
+exports.DevelopmentBuildConfiguration = DevelopmentBuildConfiguration;
 DevelopmentBuildConfiguration.getServerManifests = (currentServiceId) => {
     let serverManifests = new Array();
     return serverManifests;
@@ -34,4 +35,3 @@ DevelopmentBuildConfiguration.clearState = () => {
     DevelopmentBuildConfiguration._disableBuild = false;
 };
 DevelopmentBuildConfiguration.clientSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentBuildConfiguration.getServerManifests, DevelopmentBuildConfiguration.clearState));
-exports.DevelopmentBuildConfiguration = DevelopmentBuildConfiguration;

package/internal-do-not-import-from-here/DevelopmentEnvironment.js

@@ -23,7 +23,7 @@ class DevelopmentEnvironment {
         return new DevelopmentBuildConfiguration_1.DevelopmentBuildConfiguration();
     }
 }
+exports.DevelopmentEnvironment = DevelopmentEnvironment;
 DevelopmentEnvironment.localOverride = () => {
     return new DevelopmentEnvironment(true);
 };
-exports.DevelopmentEnvironment = DevelopmentEnvironment;

package/internal-do-not-import-from-here/DevelopmentHostingEnvironment.js

@@ -76,6 +76,7 @@ class DevelopmentHostingEnvironment {
         };
     }
 }
+exports.DevelopmentHostingEnvironment = DevelopmentHostingEnvironment;
 DevelopmentHostingEnvironment.getServerManifests = (currentServiceId) => {
     let serverManifests = new Array();
     return serverManifests;
@@ -84,4 +85,3 @@ DevelopmentHostingEnvironment.clearState = () => {
     devHosting = null;
 };
 DevelopmentHostingEnvironment.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentHostingEnvironment.getServerManifests, DevelopmentHostingEnvironment.clearState));
-exports.DevelopmentHostingEnvironment = DevelopmentHostingEnvironment;

package/internal-do-not-import-from-here/ImportManifestRegistry.js

@@ -4,6 +4,7 @@ exports.ImportManifestRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class ImportManifestRegistry {
 }
+exports.ImportManifestRegistry = ImportManifestRegistry;
 ImportManifestRegistry.manifestPackagePaths = [];
 ImportManifestRegistry.add = (path) => {
     // use Set to filter duplicate
@@ -22,4 +23,3 @@ ImportManifestRegistry.clearState = () => {
     ImportManifestRegistry.manifestPackagePaths = [];
 };
 ImportManifestRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ImportManifestRegistry.getClientManifests, ImportManifestRegistry.clearState));
-exports.ImportManifestRegistry = ImportManifestRegistry;

package/internal-do-not-import-from-here/LoadableManifestRegistry.js

@@ -77,17 +77,18 @@ class CircularDependencyValidator {
 class LoadableManifestRegistry {
     static getManifestTargetName(target) {
         switch (target.toString()) {
-            case models_1.ClientManifestTargetTypes.Public.toString():
+            case models_1.ClientManifestTargetTypes.public.toString():
                 return "public";
-            case models_1.ClientManifestTargetTypes.Admin.toString():
+            case models_1.ClientManifestTargetTypes.admin.toString():
                 return "admin";
-            case models_1.ClientManifestTargetTypes.Editor.toString():
+            case models_1.ClientManifestTargetTypes.editor.toString():
                 return "editor";
-            case models_1.ClientManifestTargetTypes.Docs.toString():
+            case models_1.ClientManifestTargetTypes.docs.toString():
                 return "docs";
         }
     }
 }
+exports.LoadableManifestRegistry = LoadableManifestRegistry;
 _a = LoadableManifestRegistry;
 LoadableManifestRegistry.ManifestDependencies = new Map();
 LoadableManifestRegistry.WithNoManifestDependencies = new Map();
@@ -98,57 +99,57 @@ LoadableManifestRegistry.RegisteredManifests = new Map();
 LoadableManifestRegistry.ClientManifestProviders = [];
 LoadableManifestRegistry.getRegisteredManifest = (manifestId) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
-    return LoadableManifestRegistry.RegisteredManifests.get(manifestId);
+    return _a.RegisteredManifests.get(manifestId);
 };
 LoadableManifestRegistry.withNoDependency = (manifestId) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
-    if (LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+    if (_a.ManifestDependencies.get(manifestId)) {
         new Error("Can't combine adding dependencies and also set withNoDependency, see manifest path: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
     }
-    LoadableManifestRegistry.WithNoManifestDependencies.set(manifestId, true);
+    _a.WithNoManifestDependencies.set(manifestId, true);
 };
 LoadableManifestRegistry.isDefineWithNoDependency = (manifestId) => {
-    return LoadableManifestRegistry.WithNoManifestDependencies.get(manifestId) === true;
+    return _a.WithNoManifestDependencies.get(manifestId) === true;
 };
 LoadableManifestRegistry.addManifestDependency = (manifestId, dependentOnManifestId, dependentManifestOmniaServiceId = null) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
     dependentOnManifestId = Utils_1.Utils.ensureValidManifestId(dependentOnManifestId, "Invalid depending manifest id");
-    if (LoadableManifestRegistry.WithNoManifestDependencies.get(manifestId) === true) {
+    if (_a.WithNoManifestDependencies.get(manifestId) === true) {
         new Error("Can't combine adding dependencies and also set withNoDependency, see manifest path: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
     }
     if (dependentManifestOmniaServiceId != null) {
         dependentManifestOmniaServiceId = Utils_1.Utils.ensureValidServiceId(dependentManifestOmniaServiceId, "Invalid depending omnia service id");
     }
     let dependency = new ManifestDependency(dependentOnManifestId, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), dependentManifestOmniaServiceId);
-    if (LoadableManifestRegistry.ManifestDependencies.get(manifestId) == null) {
-        LoadableManifestRegistry.ManifestDependencies.set(manifestId, []);
+    if (_a.ManifestDependencies.get(manifestId) == null) {
+        _a.ManifestDependencies.set(manifestId, []);
     }
     let alreadyAdded = false;
-    for (let currDep of LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+    for (let currDep of _a.ManifestDependencies.get(manifestId)) {
         if (currDep.manifestId.toString() === dependentOnManifestId.toString()) {
             alreadyAdded = true;
             break;
         }
     }
     if (!alreadyAdded) {
-        LoadableManifestRegistry.ManifestDependencies.get(manifestId).push(dependency);
+        _a.ManifestDependencies.get(manifestId).push(dependency);
     }
 };
 LoadableManifestRegistry.getManifestDependencies = (manifestId, currentServiceId) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
     currentServiceId = Utils_1.Utils.ensureValidServiceId(currentServiceId);
     let result = [];
-    if (!LoadableManifestRegistry.WithNoManifestDependencies.get(manifestId) &&
-        !LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
-        result = LoadableManifestRegistry.getDefaultDependencies();
+    if (!_a.WithNoManifestDependencies.get(manifestId) &&
+        !_a.ManifestDependencies.get(manifestId)) {
+        result = _a.getDefaultDependencies();
         for (let def of result) {
             if (def.resourceId == manifestId) {
                 throw new Error("Cirkular (default) dependency error for manifest id " + manifestId + ". Please specify withDependency or withNoDependency, as current manifest is part of default");
             }
         }
     }
-    else if (LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
-        for (let dep of LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+    else if (_a.ManifestDependencies.get(manifestId)) {
+        for (let dep of _a.ManifestDependencies.get(manifestId)) {
             const bundleIdentity = {
                 resourceId: dep.manifestId
             };
@@ -163,10 +164,10 @@ LoadableManifestRegistry.getManifestDependencies = (manifestId, currentServiceId
 //This only seems to be used for detecting changes
 LoadableManifestRegistry.getAllManifestDependencies = () => {
     const dependencies = new Map();
-    for (const regis of LoadableManifestRegistry.ManifestDependencies) {
+    for (const regis of _a.ManifestDependencies) {
         if (regis[1].length == 0 &&
-            LoadableManifestRegistry.WithNoManifestDependencies.get(regis[0]) !== true) {
-            dependencies.set(regis[0], LoadableManifestRegistry.getDefaultDependencies());
+            _a.WithNoManifestDependencies.get(regis[0]) !== true) {
+            dependencies.set(regis[0], _a.getDefaultDependencies());
         }
         else {
             dependencies.set(regis[0], regis[1]);
@@ -179,14 +180,14 @@ LoadableManifestRegistry.addManifestVersion = (manifestId, type, version) => {
     if (!version) {
         throw new Error("Can't add manifest version null/empty/undefined to manifest id: " + manifestId);
     }
-    if (!LoadableManifestRegistry.ManifestVersions.get(manifestId)) {
-        LoadableManifestRegistry.ManifestVersions.set(manifestId, {});
+    if (!_a.ManifestVersions.get(manifestId)) {
+        _a.ManifestVersions.set(manifestId, {});
     }
-    LoadableManifestRegistry.ManifestVersions.get(manifestId)[type] = version;
+    _a.ManifestVersions.get(manifestId)[type] = version;
 };
 LoadableManifestRegistry.getManifestVersion = (manifestId) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't get manifest version for manifest id null/empty/undefined.");
-    let result = LoadableManifestRegistry.ManifestVersions.get(manifestId);
+    let result = _a.ManifestVersions.get(manifestId);
     if (!result) {
         throw new Error(`Unexpected manifest ${manifestId}, build step has not set manifest version`);
     }
@@ -194,23 +195,23 @@ LoadableManifestRegistry.getManifestVersion = (manifestId) => {
 };
 LoadableManifestRegistry.addManifestBundleType = (manifestId, type) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't add manifest targetType to manifest id null/empty/undefined.");
-    if (LoadableManifestRegistry.ManifestFileTypes.get(manifestId) == null) {
-        LoadableManifestRegistry.ManifestFileTypes.set(manifestId, []);
+    if (_a.ManifestFileTypes.get(manifestId) == null) {
+        _a.ManifestFileTypes.set(manifestId, []);
     }
     let exists = false;
-    for (let t of LoadableManifestRegistry.ManifestFileTypes.get(manifestId)) {
+    for (let t of _a.ManifestFileTypes.get(manifestId)) {
         if (t === type) {
             exists = true;
             break;
         }
     }
     if (!exists) {
-        LoadableManifestRegistry.ManifestFileTypes.get(manifestId).push(type);
+        _a.ManifestFileTypes.get(manifestId).push(type);
     }
 };
 LoadableManifestRegistry.getManifestBundleTypes = (manifestId) => {
     manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't add manifest bundle target types for manifest id null/empty/undefined.");
-    let result = LoadableManifestRegistry.ManifestFileTypes.get(manifestId);
+    let result = _a.ManifestFileTypes.get(manifestId);
     if (!result ||
         (result &&
             result.length == 0)) {
@@ -228,13 +229,13 @@ LoadableManifestRegistry.registerManifest = (manifest) => {
     }
     manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
     manifest.resourceName = manifest.resourceName;
-    return LoadableManifestRegistry.RegisteredManifests.set(manifest.resourceId, manifest);
+    return _a.RegisteredManifests.set(manifest.resourceId, manifest);
 };
 LoadableManifestRegistry.registerManifestProvider = (provider) => {
     if (!provider) {
         throw new Error("Unexpected state, loadable client manifest provider can't be null/undefined");
     }
-    LoadableManifestRegistry.ClientManifestProviders.push(provider);
+    _a.ClientManifestProviders.push(provider);
 };
 LoadableManifestRegistry.getClientManifests = (currentServiceId) => {
     if (!currentServiceId) {
@@ -243,43 +244,43 @@ LoadableManifestRegistry.getClientManifests = (currentServiceId) => {
     currentServiceId = Utils_1.Utils.ensureValidServiceId(currentServiceId);
     let manifests = [];
     //Note the order here could be important as the manifest types are ordered like this client side
-    for (let i = LoadableManifestRegistry.ClientManifestProviders.length - 1; i >= 0; i--) {
-        let provider = LoadableManifestRegistry.ClientManifestProviders[i];
+    for (let i = _a.ClientManifestProviders.length - 1; i >= 0; i--) {
+        let provider = _a.ClientManifestProviders[i];
         let providerManifests = provider.getClientLoadableManifests(currentServiceId);
         for (let m of providerManifests) {
             //Check conflict etc
-            LoadableManifestRegistry.addClientManifest(currentServiceId, m);
+            _a.addClientManifest(currentServiceId, m);
         }
     }
-    LoadableManifestRegistry.validateDependencies(currentServiceId);
-    for (const m of LoadableManifestRegistry.ClientManifests.values()) {
+    _a.validateDependencies(currentServiceId);
+    for (const m of _a.ClientManifests.values()) {
         manifests.push(m);
     }
     return manifests;
 };
 LoadableManifestRegistry.clearState = () => {
-    for (let provider of LoadableManifestRegistry.ClientManifestProviders) {
+    for (let provider of _a.ClientManifestProviders) {
         provider.clearState();
     }
-    LoadableManifestRegistry.ClientManifests = new Map();
-    LoadableManifestRegistry.ClientManifestProviders = [];
-    LoadableManifestRegistry.ManifestDependencies = new Map();
+    _a.ClientManifests = new Map();
+    _a.ClientManifestProviders = [];
+    _a.ManifestDependencies = new Map();
 };
 LoadableManifestRegistry.validateDependencies = (currentServiceId) => {
-    for (let manifestIdWithDep of LoadableManifestRegistry.ManifestDependencies.keys()) {
+    for (let manifestIdWithDep of _a.ManifestDependencies.keys()) {
         const clientManifestWithDep = _a.ClientManifests.get(manifestIdWithDep);
-        for (let dep of LoadableManifestRegistry.ManifestDependencies.get(manifestIdWithDep)) {
+        for (let dep of _a.ManifestDependencies.get(manifestIdWithDep)) {
             if (dep.externalOmniaServiceId == null) {
                 const manifestDependency = _a.ClientManifests.get(dep.manifestId);
                 // validate dependencies across manifest targets
                 // only allow dependency to manifest the same target or is public target
-                if (clientManifestWithDep.target !== manifestDependency.target && manifestDependency.target !== models_1.ClientManifestTargetTypes.Public) {
+                if (clientManifestWithDep.target !== manifestDependency.target && manifestDependency.target !== models_1.ClientManifestTargetTypes.public) {
                     (0, tooling_1.log)(`Manifest: ${manifestIdWithDep} with target ${_a.getManifestTargetName(clientManifestWithDep.target)} has dependency to ${dep.manifestId} with target ${_a.getManifestTargetName(manifestDependency.target)}`, tooling_1.LogTypes.Error);
                     console.log(clientManifestWithDep, manifestDependency);
                     throw new Error("Have exception");
                 }
             }
-            new CircularDependencyValidator(LoadableManifestRegistry.ManifestDependencies, LoadableManifestRegistry.WithNoManifestDependencies, LoadableManifestRegistry.getDefaultDependencies(), manifestIdWithDep, dep);
+            new CircularDependencyValidator(_a.ManifestDependencies, _a.WithNoManifestDependencies, _a.getDefaultDependencies(), manifestIdWithDep, dep);
             /* This check is prob not needed, as groups is just a package from which individual stuff is loaded
             //Check groups
             if (LoadableManifestRegistry.ClientManifests[manifestIdWithDep].manifestType == ClientManifestTypes.ManifestGroup) {
@@ -304,7 +305,7 @@ LoadableManifestRegistry.validateDependencies = (currentServiceId) => {
                 throw new Error("Manifest: " + dep.manifestPath + " has dependency to " + dep.manifestId + " which is marked as external, but the omnia service id matches the current omnia service id: " + currentServiceId + ". Add dependency as none external or insure a correct omnia service id");
             }
             if (dep.externalOmniaServiceId == null &&
-                LoadableManifestRegistry.ClientManifests.get(dep.manifestId) == null) {
+                _a.ClientManifests.get(dep.manifestId) == null) {
                 throw new Error("Manifest: " + dep.manifestPath + " has dependency to " + dep.manifestId + " which could not be found. Mark the dependency as external if it's not part of the current project.");
             }
         }
@@ -320,13 +321,13 @@ LoadableManifestRegistry.addClientManifest = (omniaServiceId, manifest) => {
     if (manifest.omniaServiceId && manifest.omniaServiceId !== omniaServiceId) {
         throw new Error("Unexpected state, client manifest omnia service id should match current omnia service id:" + omniaServiceId + " manifest: " + JSON.stringify(manifest));
     }
-    if (LoadableManifestRegistry.ClientManifests.get(manifest.resourceId) != null) {
+    if (_a.ClientManifests.get(manifest.resourceId) != null) {
         throw new Error("Unexpected state, client manifest id's should be unique and added once. Already added: "
-            + JSON.stringify(LoadableManifestRegistry.ClientManifests.get(manifest.resourceId))
+            + JSON.stringify(_a.ClientManifests.get(manifest.resourceId))
             + " trying to add: " +
             JSON.stringify(manifest));
     }
-    LoadableManifestRegistry.ClientManifests.set(manifest.resourceId, manifest);
+    _a.ClientManifests.set(manifest.resourceId, manifest);
 };
 LoadableManifestRegistry.getDefaultDependencies = () => {
     return [
@@ -338,5 +339,4 @@ LoadableManifestRegistry.getDefaultDependencies = () => {
     ];
 };
 //Just dummy to register subscriber
-LoadableManifestRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(LoadableManifestRegistry.getClientManifests, LoadableManifestRegistry.clearState));
-exports.LoadableManifestRegistry = LoadableManifestRegistry;
+LoadableManifestRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(_a.getClientManifests, _a.clearState));

package/internal-do-not-import-from-here/LocalizationComposer.js

@@ -49,6 +49,7 @@ class Localization {
         return this;
     }
 }
+exports.Localization = Localization;
 Localization.localizationRegistrations = [];
 Localization.getRegistrations = () => {
     return Localization.localizationRegistrations;
@@ -64,7 +65,6 @@ Localization.clearState = () => {
     _localizations = {};
 };
 Localization.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(Localization.getClientManifests, Localization.clearState));
-exports.Localization = Localization;
 class LocalizationNamespaceComposer {
     constructor(root, manifestId) {
         this.add = (localizeObject) => {

package/internal-do-not-import-from-here/ManifestGroupComposer.js

@@ -49,7 +49,7 @@ class ManifestGroupComposer {
             this.manifest.resourceName = manifestName;
         }
         if (this.manifest.target === undefined) {
-            this.manifest.target = models_1.ClientManifestTargetTypes.Public;
+            this.manifest.target = models_1.ClientManifestTargetTypes.public;
         }
     }
 }

package/internal-do-not-import-from-here/ManifestGroupRegistry.js

@@ -63,6 +63,7 @@ class ManifestGroupRegistry {
         };
     }
 }
+exports.ManifestGroupRegistry = ManifestGroupRegistry;
 ManifestGroupRegistry.ManifestGroupRegistrations = new Map();
 ManifestGroupRegistry._registeredManifestProvider = false;
 ManifestGroupRegistry.registerManifestGroup = (manifest, groupOptions) => {
@@ -157,4 +158,3 @@ ManifestGroupRegistry.clearManifestGroupRegistrations = () => {
     ManifestGroupRegistry.ManifestGroupRegistrations = new Map();
 };
 ManifestGroupRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(() => { return new Array(); }, ManifestGroupRegistry.clearManifestGroupRegistrations));
-exports.ManifestGroupRegistry = ManifestGroupRegistry;

package/internal-do-not-import-from-here/ManifestRegistry.js

@@ -19,6 +19,7 @@ class StaticServerManifestProviderProxy {
 exports.StaticServerManifestProviderProxy = StaticServerManifestProviderProxy;
 class ManifestRegistry {
 }
+exports.ManifestRegistry = ManifestRegistry;
 ManifestRegistry.CurrentManifestPath = null;
 ManifestRegistry.ClientManifestProviders = [];
 ManifestRegistry.ServerManifestProviders = [];
@@ -49,15 +50,15 @@ ManifestRegistry.getCurrentManifestPath = () => {
 ManifestRegistry.getClientManifests = (currentServiceId) => {
     currentServiceId = Utils_1.Utils.ensureValidServiceId(currentServiceId, "Can't get client manifests for service id undefined/empty/null");
     const manifestsByTarget = {
-        [models_1.ClientManifestTargetTypes.Public]: {
-            target: models_1.ClientManifestTargetTypes.Public,
+        [models_1.ClientManifestTargetTypes.public]: {
+            target: models_1.ClientManifestTargetTypes.public,
             omniaServiceId: currentServiceId
         }
     };
     for (let provider of ManifestRegistry.ClientManifestProviders) {
         let providerManifests = provider.getClientManifests(currentServiceId);
         for (let m of providerManifests) {
-            let target = manifestsByTarget[models_1.ClientManifestTargetTypes.Public]; // default is public target
+            let target = manifestsByTarget[models_1.ClientManifestTargetTypes.public]; // default is public target
             if (m.target) {
                 if (manifestsByTarget[m.target] === undefined) {
                     manifestsByTarget[m.target] = { target: m.target, omniaServiceId: currentServiceId };
@@ -108,4 +109,3 @@ ManifestRegistry.addResetableProvider = (provider) => {
         ManifestRegistry.ResetableManifestProviders.push(provider);
     }
 };
-exports.ManifestRegistry = ManifestRegistry;

package/internal-do-not-import-from-here/RequestedResourcesRegistry.js

@@ -8,6 +8,7 @@ const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class RequestedResourcesRegistry {
 }
+exports.RequestedResourcesRegistry = RequestedResourcesRegistry;
 RequestedResourcesRegistry.RequestedResources = {};
 RequestedResourcesRegistry.AddSql = (option) => {
     if (!models_1.Guid.isValid(option.uniqueId)) {
@@ -62,4 +63,3 @@ RequestedResourcesRegistry.clearState = () => {
     RequestedResourcesRegistry.RequestedResources = {};
 };
 RequestedResourcesRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequestedResourcesRegistry.getServerManifests, RequestedResourcesRegistry.clearState));
-exports.RequestedResourcesRegistry = RequestedResourcesRegistry;

package/internal-do-not-import-from-here/RequiredAzureAdAppPermissionRegistry.js

@@ -21,6 +21,7 @@ class RequiredAzureAdAppPermissionRegistry {
         }
     }
 }
+exports.RequiredAzureAdAppPermissionRegistry = RequiredAzureAdAppPermissionRegistry;
 RequiredAzureAdAppPermissionRegistry.RequiredApis = {};
 RequiredAzureAdAppPermissionRegistry.getServerManifests = (currentServiceId) => {
     let serverManifests = new Array();
@@ -33,4 +34,3 @@ RequiredAzureAdAppPermissionRegistry.clearState = () => {
     RequiredAzureAdAppPermissionRegistry.RequiredApis = {};
 };
 RequiredAzureAdAppPermissionRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(RequiredAzureAdAppPermissionRegistry.getServerManifests, RequiredAzureAdAppPermissionRegistry.clearState));
-exports.RequiredAzureAdAppPermissionRegistry = RequiredAzureAdAppPermissionRegistry;

package/internal-do-not-import-from-here/ResourceRegistry.js

@@ -75,6 +75,7 @@ class ResourceRegistry {
         };
     }
 }
+exports.ResourceRegistry = ResourceRegistry;
 ResourceRegistry.ResourceRegistrations = new Map();
 ResourceRegistry.registerResource = (manifest, resourceDescription) => {
     ResourceRegistry.ensureCorrectManifest(manifest);
@@ -220,4 +221,3 @@ ResourceRegistry.ensureCorrectManifest = (manifest) => {
     }
     manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
 };
-exports.ResourceRegistry = ResourceRegistry;

package/internal-do-not-import-from-here/ResourcesComposer.js

@@ -75,7 +75,7 @@ class ResourcesComposer extends ComposerBase_1.ComposerBase {
             this.manifest.resourceName = manifestName;
         }
         if (this.manifest.target === undefined) {
-            this.manifest.target = models_1.ClientManifestTargetTypes.Public;
+            this.manifest.target = models_1.ClientManifestTargetTypes.public;
         }
     }
 }

package/internal-do-not-import-from-here/SecurityProviderManifestRegistry.js

@@ -5,6 +5,7 @@ const ManifestRegistry_1 = require("./ManifestRegistry");
 const index_1 = require("./models/index");
 class SecurityProviderManifestRegistry {
 }
+exports.SecurityProviderManifestRegistry = SecurityProviderManifestRegistry;
 SecurityProviderManifestRegistry.SecurityProviders = [];
 SecurityProviderManifestRegistry.getServerManifests = (currentServiceId) => {
     let result = [];
@@ -29,4 +30,3 @@ SecurityProviderManifestRegistry.clearState = () => {
     SecurityProviderManifestRegistry.SecurityProviders = [];
 };
 SecurityProviderManifestRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(SecurityProviderManifestRegistry.getServerManifests, SecurityProviderManifestRegistry.clearState));
-exports.SecurityProviderManifestRegistry = SecurityProviderManifestRegistry;

package/internal-do-not-import-from-here/ServiceAppRegistry.js

@@ -8,6 +8,7 @@ const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class ServiceAppRegistry {
 }
+exports.ServiceAppRegistry = ServiceAppRegistry;
 ServiceAppRegistry.AddedAppDefinitions = {};
 ServiceAppRegistry.AddAppDefinition = (appDefinitionId, option) => {
     if (appDefinitionId == models_1.Guid.empty) {
@@ -34,4 +35,3 @@ ServiceAppRegistry.clearState = () => {
     ServiceAppRegistry.AddedAppDefinitions = {};
 };
 ServiceAppRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceAppRegistry.getServerManifests, ServiceAppRegistry.clearState));
-exports.ServiceAppRegistry = ServiceAppRegistry;

package/internal-do-not-import-from-here/ServiceComposer.d.ts

@@ -19,7 +19,7 @@ export interface IServiceComposer {
     */
     AsWorker: () => IWorkerServiceComposer;
     /**
-    * Register service to be of custom type (to install heml)
+    * Register service to be of custom type (to install helm)
     */
     AsCustom: () => ICustomServiceComposer;
 }

package/internal-do-not-import-from-here/ServiceFeatureRegistry.js

@@ -9,6 +9,7 @@ const models_1 = require("../../fx-models");
 const AzureAdAppPermissionHelper_1 = require("./AzureAdAppPermissionHelper");
 class ServiceFeatureRegistry {
 }
+exports.ServiceFeatureRegistry = ServiceFeatureRegistry;
 ServiceFeatureRegistry.AddedFeatures = {};
 ServiceFeatureRegistry.AddFeature = (featureId, option) => {
     if (featureId == models_1.Guid.empty) {
@@ -36,4 +37,3 @@ ServiceFeatureRegistry.clearState = () => {
     ServiceFeatureRegistry.AddedFeatures = {};
 };
 ServiceFeatureRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceFeatureRegistry.getServerManifests, ServiceFeatureRegistry.clearState));
-exports.ServiceFeatureRegistry = ServiceFeatureRegistry;

package/internal-do-not-import-from-here/ServiceManifestRegistry.js

@@ -5,6 +5,7 @@ const index_1 = require("./models/index");
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class ServiceManifestRegistry {
 }
+exports.ServiceManifestRegistry = ServiceManifestRegistry;
 ServiceManifestRegistry.Service = null;
 ServiceManifestRegistry.AddService = (service) => {
     if (!(service.serviceType === index_1.ServiceTypes.WebApp ||
@@ -34,4 +35,3 @@ ServiceManifestRegistry.clearState = () => {
     ServiceManifestRegistry.Service = null;
 };
 ServiceManifestRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceManifestRegistry.getServerManifests, ServiceManifestRegistry.clearState));
-exports.ServiceManifestRegistry = ServiceManifestRegistry;

package/internal-do-not-import-from-here/ServiceRoleRegistry.js

@@ -8,6 +8,7 @@ const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class ServiceRoleRegistry {
 }
+exports.ServiceRoleRegistry = ServiceRoleRegistry;
 ServiceRoleRegistry.AddedRoleDefinitions = {};
 ServiceRoleRegistry.AddRoleDefinition = (roleDefinitionId, option) => {
     if (roleDefinitionId == models_1.Guid.empty) {
@@ -34,4 +35,3 @@ ServiceRoleRegistry.clearState = () => {
     ServiceRoleRegistry.AddedRoleDefinitions = {};
 };
 ServiceRoleRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceRoleRegistry.getServerManifests, ServiceRoleRegistry.clearState));
-exports.ServiceRoleRegistry = ServiceRoleRegistry;

package/internal-do-not-import-from-here/Utils.js

@@ -66,6 +66,7 @@ class Utils {
         return [apiPath, configuration];
     }
 }
+exports.Utils = Utils;
 Utils.ensureValidManifestId = (id, errorMsg) => {
     if (!id) {
         throw new Error(errorMsg ? errorMsg : "Invalid manifest id, can't be null/empty or undefined");
@@ -145,4 +146,3 @@ Utils.isNull = (obj) => {
 Utils.isNullOrEmpty = (obj) => {
     return Utils.isNull(obj) || obj === "";
 };
-exports.Utils = Utils;

package/internal-do-not-import-from-here/models/Build.d.ts

@@ -32,6 +32,11 @@ export interface BuildOptions {
     * Usage: reference:["omnia.vendor.manifest.json"]
     */
     reference?: Array<string>;
+    /**
+    * Specifies a list prebuild webpack manifests to improve build next time.
+    * Usage: reference:["omnia.vendor.manifest.json"]
+    */
+    webpackManifests?: Array<string>;
     /**
      * Prevent webpack from parsing any files matching the given regular expression(s).
      * Ignored files should not have calls to import, require, define or any other importing mechanism.
@@ -51,9 +56,9 @@ export interface BuildOptions {
     */
     docResourceManifestId?: GuidValue;
     /**
-    * Create a namespace to web component tag
+    * Create a namespace to element name.
     */
-    webComponentNamespace?: string;
+    componentNamespace?: string;
 }
 export interface CircularDependencyOptions {
     /**

package/internal-do-not-import-from-here/models/ComponentComposer.d.ts

@@ -8,15 +8,8 @@ export interface ElementOptions {
         Paths should be relative project root, or relative current folder
     */
     entryPoint: string;
-    /** The path to a .d.ts file containing the intrinsic declaration for the web component
-    e.g. './ComponentFolder/ComponentTypings.d.ts'
-    Paths should be relative project root or relative current folder
-    */
+    namespace?: string;
     typings?: Array<string>;
-    /** The path to a .d.ts file containing the intrinsic declaration for the web component
-    e.g. './ComponentFolder/ComponentTypings.d.ts'
-    Paths should be relative project root or relative current folder
-    */
     documentations?: Array<string>;
 }
 export interface ResourceBuildOptions {

package/internal-do-not-import-from-here/models/Enums.d.ts

@@ -34,8 +34,7 @@ export declare enum ServerManifestTypes {
     ServiceFeature = "servicefeature",
     ServiceAppDefinition = "serviceappdefinition",
     AzureADAppPermission = "azureadapppermission",
-    ServiceRoleDefinition = "serviceroledefinition",
-    HemlProvider = "hemlprovider"
+    ServiceRoleDefinition = "serviceroledefinition"
 }
 export declare enum BundleTargetTypes {
     Javascript = "js",

package/internal-do-not-import-from-here/models/Enums.js

@@ -6,36 +6,36 @@ var RequestedResourceTypes;
     RequestedResourceTypes["SqlDatabase"] = "SqlDatabase";
     RequestedResourceTypes["SqlElasticPoolDatabase"] = "SqlElasticPoolDatabase";
     RequestedResourceTypes["PersistentDisk"] = "PersistentDisk";
-})(RequestedResourceTypes = exports.RequestedResourceTypes || (exports.RequestedResourceTypes = {}));
+})(RequestedResourceTypes || (exports.RequestedResourceTypes = RequestedResourceTypes = {}));
 var ServiceTypes;
 (function (ServiceTypes) {
     ServiceTypes["WebApp"] = "WebAppService";
     ServiceTypes["Worker"] = "WorkerService";
     ServiceTypes["Custom"] = "CustomService";
-})(ServiceTypes = exports.ServiceTypes || (exports.ServiceTypes = {}));
+})(ServiceTypes || (exports.ServiceTypes = ServiceTypes = {}));
 var SecurityProviderTypes;
 (function (SecurityProviderTypes) {
     SecurityProviderTypes["RoleBased"] = "RoleBasedProvider";
     SecurityProviderTypes["Combined"] = "CombinedProviders";
-})(SecurityProviderTypes = exports.SecurityProviderTypes || (exports.SecurityProviderTypes = {}));
+})(SecurityProviderTypes || (exports.SecurityProviderTypes = SecurityProviderTypes = {}));
 var SecurityRoleScopes;
 (function (SecurityRoleScopes) {
     SecurityRoleScopes["Tenant"] = "Tenant";
     SecurityRoleScopes["SiteCollection"] = "SiteCollection";
     SecurityRoleScopes["Site"] = "Site";
-})(SecurityRoleScopes = exports.SecurityRoleScopes || (exports.SecurityRoleScopes = {}));
+})(SecurityRoleScopes || (exports.SecurityRoleScopes = SecurityRoleScopes = {}));
 var RuleLogicalOperator;
 (function (RuleLogicalOperator) {
     RuleLogicalOperator["And"] = "&&";
     RuleLogicalOperator["Or"] = "||";
-})(RuleLogicalOperator = exports.RuleLogicalOperator || (exports.RuleLogicalOperator = {}));
+})(RuleLogicalOperator || (exports.RuleLogicalOperator = RuleLogicalOperator = {}));
 var ClientManifestTypes;
 (function (ClientManifestTypes) {
     ClientManifestTypes["Component"] = "webcomponent";
     ClientManifestTypes["ManifestGroup"] = "groupedResouresAndComponents";
     ClientManifestTypes["Resource"] = "resource";
     ClientManifestTypes["BlockedManifest"] = "blockedManifest";
-})(ClientManifestTypes = exports.ClientManifestTypes || (exports.ClientManifestTypes = {}));
+})(ClientManifestTypes || (exports.ClientManifestTypes = ClientManifestTypes = {}));
 var ServerManifestTypes;
 (function (ServerManifestTypes) {
     ServerManifestTypes["SecurityProvider"] = "securityprovider";
@@ -45,10 +45,9 @@ var ServerManifestTypes;
     ServerManifestTypes["ServiceAppDefinition"] = "serviceappdefinition";
     ServerManifestTypes["AzureADAppPermission"] = "azureadapppermission";
     ServerManifestTypes["ServiceRoleDefinition"] = "serviceroledefinition";
-    ServerManifestTypes["HemlProvider"] = "hemlprovider";
-})(ServerManifestTypes = exports.ServerManifestTypes || (exports.ServerManifestTypes = {}));
+})(ServerManifestTypes || (exports.ServerManifestTypes = ServerManifestTypes = {}));
 var BundleTargetTypes;
 (function (BundleTargetTypes) {
     BundleTargetTypes["Javascript"] = "js";
     BundleTargetTypes["Stylesheet"] = "css";
-})(BundleTargetTypes = exports.BundleTargetTypes || (exports.BundleTargetTypes = {}));
+})(BundleTargetTypes || (exports.BundleTargetTypes = BundleTargetTypes = {}));

package/internal-do-not-import-from-here/models/ServerManifests.d.ts

@@ -99,6 +99,7 @@ export interface AppResourceType {
     parameters: Array<ServiceParam>;
     providedParameters: Array<ServiceParam>;
     requiredFeatures?: Array<GuidValue>;
+    requiredEnvironments?: Array<string>;
 }
 export interface ServiceAppDefinitionOption {
     title: string;
@@ -219,7 +220,7 @@ export interface ServiceBase extends ServiceOptions {
     optionalService: boolean;
 }
 export interface CustomService extends ServiceBase {
-    hemlCommand?: string;
+    helmCommand?: string;
 }
 export interface ServiceManifest extends ServiceBase, ServerManifest {
 }

package/internal-do-not-import-from-here/task.js

@@ -150,7 +150,8 @@ function build(scanFolders, cleanOutputBeforeBuild) {
                     resolve();
                 }
                 else if (process.argv.length > 0
-                    && process.argv.find(argv => argv === "--package") !== undefined) {
+                    && (process.argv.find(argv => argv === "--package") !== undefined
+                        || process.argv.find(argv => argv === "--webpackManifest") !== undefined)) {
                     cleanOutput = false;
                     afterScanManifest()
                         .then(beforeBundleManifest, chainError)
@@ -370,13 +371,13 @@ function afterGeneratedManifestsMetadata(data) {
 }
 function getManifestFileName(target) {
     switch (target.toString()) {
-        case fx_models_1.ClientManifestTargetTypes.Public.toString():
+        case fx_models_1.ClientManifestTargetTypes.public.toString():
             return `${getServiceId()}_public_manifests.json`;
-        case fx_models_1.ClientManifestTargetTypes.Admin.toString():
+        case fx_models_1.ClientManifestTargetTypes.admin.toString():
             return `${getServiceId()}_admin_manifests.json`;
-        case fx_models_1.ClientManifestTargetTypes.Editor.toString():
+        case fx_models_1.ClientManifestTargetTypes.editor.toString():
             return `${getServiceId()}_editor_manifests.json`;
-        case fx_models_1.ClientManifestTargetTypes.Docs.toString():
+        case fx_models_1.ClientManifestTargetTypes.docs.toString():
             return `${getServiceId()}_docs_manifests.json`;
     }
 }
@@ -492,7 +493,7 @@ function ensureFolder(folderPath) {
 function chainError(err) {
     return Promise.reject(err);
 }
-function getManifestJsonByTarget(target = fx_models_1.ClientManifestTargetTypes.Public) {
+function getManifestJsonByTarget(target = fx_models_1.ClientManifestTargetTypes.public) {
     if (!_manifestJsonObject || _manifestJsonObject[target] === undefined) {
         _manifestJsonObject = _manifestJsonObject || {};
         _manifestJsonObject[target] = null;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/tooling-composers",
   "license": "MIT",
-  "version": "8.0.112-vnext",
+  "version": "8.0.113-dev",
   "description": "Provide tooling to work with manifest things.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.112-vnext",
-    "@omnia/tooling": "8.0.112-vnext",
+    "@omnia/fx-models": "8.0.113-dev",
+    "@omnia/tooling": "8.0.113-dev",
     "deep-extend": "0.6.0",
     "fs-extra": "11.1.0",
     "del": "6.0.0",