@omnia/tooling-composers 8.0.128-dev → 8.0.130-dev

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

@@ -74,150 +74,150 @@ class ResourceRegistry {
             ResourceRegistry.ResourceRegistrations = new Map();
         };
     }
-}
-exports.ResourceRegistry = ResourceRegistry;
-ResourceRegistry.ResourceRegistrations = new Map();
-ResourceRegistry.registerResource = (manifest, resourceDescription) => {
-    ResourceRegistry.ensureCorrectManifest(manifest);
-    if (!resourceDescription) {
-        throw new Error("Can't register resource with missing resourceDescription");
-    }
-    if (!resourceDescription.resourcePaths ||
-        (resourceDescription.resourcePaths && resourceDescription.resourcePaths.length <= 0)) {
-        throw new Error("Can't register resources with missing mandatory attributes: " + JSON.stringify(resourceDescription));
-    }
-    if (ResourceRegistry.ResourceRegistrations.get(manifest.resourceId) == null) {
-        ResourceRegistry.ResourceRegistrations.set(manifest.resourceId, new Array());
-    }
-    ResourceRegistry.ResourceRegistrations.get(manifest.resourceId).push(new ResourceRegistration(resourceDescription, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
-};
-ResourceRegistry.addOrdering = (manifest, orderOption) => {
-    ResourceRegistry.ensureCorrectManifest(manifest);
-    if (orderOption &&
-        orderOption.priority) {
-        let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
-        if (registrationsForBundle == null) {
-            throw new Error("Unexpected state, ordering should apply to the last registered resource description");
-        }
-        let lastAdded = registrationsForBundle.pop();
-        if (!lastAdded ||
-            (lastAdded &&
-                lastAdded.manifest !== manifest)) {
-            throw new Error("Unexpected state, ordering should apply to the last registered resource description");
-        }
-        lastAdded.orderOptions = orderOption;
-        let index = -1;
-        for (let i = 0; i < registrationsForBundle.length; i++) {
-            if (registrationsForBundle[i].orderOptions == null ||
-                (registrationsForBundle[i].orderOptions &&
-                    registrationsForBundle[i].orderOptions.priority &&
-                    lastAdded.orderOptions.priority > registrationsForBundle[i].orderOptions.priority)) {
-                //Found registration without priority or a registration with lower priority
-                index = i;
-                break;
-            }
-        }
-        if (index > -1) {
-            registrationsForBundle.splice(index, 0, lastAdded);
+    static { this.ResourceRegistrations = new Map(); }
+    static { this.registerResource = (manifest, resourceDescription) => {
+        ResourceRegistry.ensureCorrectManifest(manifest);
+        if (!resourceDescription) {
+            throw new Error("Can't register resource with missing resourceDescription");
         }
-        else {
-            //Add last again
-            registrationsForBundle.push(lastAdded);
+        if (!resourceDescription.resourcePaths ||
+            (resourceDescription.resourcePaths && resourceDescription.resourcePaths.length <= 0)) {
+            throw new Error("Can't register resources with missing mandatory attributes: " + JSON.stringify(resourceDescription));
         }
-    }
-};
-ResourceRegistry.addBuildOptions = (manifest, buildOptions) => {
-    ResourceRegistry.ensureCorrectManifest(manifest);
-    if (buildOptions) {
-        let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
-        if (registrationsForBundle == null) {
-            throw new Error("Unexpected state, build options should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+        if (ResourceRegistry.ResourceRegistrations.get(manifest.resourceId) == null) {
+            ResourceRegistry.ResourceRegistrations.set(manifest.resourceId, new Array());
         }
-        if (registrationsForBundle.length > 1) {
-            throw new Error("Unexpected state, build options should only be applied to first registration, not if manifest is reopened");
+        ResourceRegistry.ResourceRegistrations.get(manifest.resourceId).push(new ResourceRegistration(resourceDescription, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
+    }; }
+    static { this.addOrdering = (manifest, orderOption) => {
+        ResourceRegistry.ensureCorrectManifest(manifest);
+        if (orderOption &&
+            orderOption.priority) {
+            let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
+            if (registrationsForBundle == null) {
+                throw new Error("Unexpected state, ordering should apply to the last registered resource description");
+            }
+            let lastAdded = registrationsForBundle.pop();
+            if (!lastAdded ||
+                (lastAdded &&
+                    lastAdded.manifest !== manifest)) {
+                throw new Error("Unexpected state, ordering should apply to the last registered resource description");
+            }
+            lastAdded.orderOptions = orderOption;
+            let index = -1;
+            for (let i = 0; i < registrationsForBundle.length; i++) {
+                if (registrationsForBundle[i].orderOptions == null ||
+                    (registrationsForBundle[i].orderOptions &&
+                        registrationsForBundle[i].orderOptions.priority &&
+                        lastAdded.orderOptions.priority > registrationsForBundle[i].orderOptions.priority)) {
+                    //Found registration without priority or a registration with lower priority
+                    index = i;
+                    break;
+                }
+            }
+            if (index > -1) {
+                registrationsForBundle.splice(index, 0, lastAdded);
+            }
+            else {
+                //Add last again
+                registrationsForBundle.push(lastAdded);
+            }
         }
-        registrationsForBundle[0].buildOptions = buildOptions;
-    }
-};
-ResourceRegistry.newCombinedRules = (manifest, rules) => {
-    ResourceRegistry.ensureCorrectManifest(manifest);
-    if (rules) {
-        Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
-        let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
-        if (registrationsForBundle == null) {
-            throw new Error("Unexpected state, load rule should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+    }; }
+    static { this.addBuildOptions = (manifest, buildOptions) => {
+        ResourceRegistry.ensureCorrectManifest(manifest);
+        if (buildOptions) {
+            let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
+            if (registrationsForBundle == null) {
+                throw new Error("Unexpected state, build options should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+            }
+            if (registrationsForBundle.length > 1) {
+                throw new Error("Unexpected state, build options should only be applied to first registration, not if manifest is reopened");
+            }
+            registrationsForBundle[0].buildOptions = buildOptions;
         }
-        if (registrationsForBundle.length > 1) {
-            throw new Error("Unexpected state, load rules should only be applied to first registration, not if manifest is reopened");
+    }; }
+    static { this.newCombinedRules = (manifest, rules) => {
+        ResourceRegistry.ensureCorrectManifest(manifest);
+        if (rules) {
+            Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
+            let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
+            if (registrationsForBundle == null) {
+                throw new Error("Unexpected state, load rule should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+            }
+            if (registrationsForBundle.length > 1) {
+                throw new Error("Unexpected state, load rules should only be applied to first registration, not if manifest is reopened");
+            }
+            //let lastAdded = registrationsForBundle[registrationsForBundle.length - 1];
+            //if (!lastAdded ||
+            //    (lastAdded &&
+            //        lastAdded.manifest !== manifest)) {
+            //    throw new Error("Unexpected state, load rules should be added to the last registered resource description");
+            //}
+            //lastAdded.loadRules = rules;
+            registrationsForBundle[0].loadRules = rules;
         }
-        //let lastAdded = registrationsForBundle[registrationsForBundle.length - 1];
-        //if (!lastAdded ||
-        //    (lastAdded &&
-        //        lastAdded.manifest !== manifest)) {
-        //    throw new Error("Unexpected state, load rules should be added to the last registered resource description");
-        //}
-        //lastAdded.loadRules = rules;
-        registrationsForBundle[0].loadRules = rules;
-    }
-};
-ResourceRegistry.addExtendApiRules = (manifest, rules) => {
-    ResourceRegistry.ensureCorrectManifest(manifest);
-    if (rules) {
-        Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
-        let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
-        if (registrationsForBundle == null) {
-            throw new Error("Unexpected state, load rule should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+    }; }
+    static { this.addExtendApiRules = (manifest, rules) => {
+        ResourceRegistry.ensureCorrectManifest(manifest);
+        if (rules) {
+            Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
+            let registrationsForBundle = ResourceRegistry.ResourceRegistrations.get(manifest.resourceId);
+            if (registrationsForBundle == null) {
+                throw new Error("Unexpected state, load rule should apply be applied to a registered manifest, no registrations found for manifest id:" + manifest.resourceId);
+            }
+            if (registrationsForBundle.length > 1) {
+                throw new Error("Unexpected state, load rules should only be applied to first registration, not if manifest is reopened");
+            }
+            registrationsForBundle[0].extendApiRules = rules;
         }
-        if (registrationsForBundle.length > 1) {
-            throw new Error("Unexpected state, load rules should only be applied to first registration, not if manifest is reopened");
+    }; }
+    static { this.getRegisteredResourceBundles = (pathJoiner) => {
+        const bundleResources = new Map();
+        if (!pathJoiner) {
+            throw new Error("Missing path joiner method");
         }
-        registrationsForBundle[0].extendApiRules = rules;
-    }
-};
-ResourceRegistry.getRegisteredResourceBundles = (pathJoiner) => {
-    const bundleResources = new Map();
-    if (!pathJoiner) {
-        throw new Error("Missing path joiner method");
-    }
-    //Resource manifests should have been ordered on insert
-    for (const regis of ResourceRegistry.ResourceRegistrations) {
-        let bundleRegistrations = regis[1];
-        if (bundleRegistrations &&
-            bundleRegistrations.length > 0) {
-            let pathsWithOtions = {
-                buildOptions: null,
-                paths: []
-            };
-            for (let r of bundleRegistrations) {
-                if (r.buildOptions) {
-                    pathsWithOtions.buildOptions = r.buildOptions;
-                }
-                if (r.manifest.resourceId !== regis[0]) {
-                    throw new Error("Unexpected state, sanity check failed, all resources should belong to same bundle, expected:" + regis[0] + " found: " + r.manifest.resourceId);
+        //Resource manifests should have been ordered on insert
+        for (const regis of ResourceRegistry.ResourceRegistrations) {
+            let bundleRegistrations = regis[1];
+            if (bundleRegistrations &&
+                bundleRegistrations.length > 0) {
+                let pathsWithOtions = {
+                    buildOptions: null,
+                    paths: []
+                };
+                for (let r of bundleRegistrations) {
+                    if (r.buildOptions) {
+                        pathsWithOtions.buildOptions = r.buildOptions;
+                    }
+                    if (r.manifest.resourceId !== regis[0]) {
+                        throw new Error("Unexpected state, sanity check failed, all resources should belong to same bundle, expected:" + regis[0] + " found: " + r.manifest.resourceId);
+                    }
+                    //for (let p of r.description.resourcePaths) {
+                    //    pathsWithOtions.paths = pathsWithOtions.paths.concat(pathJoiner(r.manifestPath, p));
+                    //}
+                    pathsWithOtions.paths = pathsWithOtions.paths.concat(pathJoiner(r.manifestPath, r.description.resourcePaths));
                 }
-                //for (let p of r.description.resourcePaths) {
-                //    pathsWithOtions.paths = pathsWithOtions.paths.concat(pathJoiner(r.manifestPath, p));
-                //}
-                pathsWithOtions.paths = pathsWithOtions.paths.concat(pathJoiner(r.manifestPath, r.description.resourcePaths));
+                bundleResources.set(regis[0], pathsWithOtions);
             }
-            bundleResources.set(regis[0], pathsWithOtions);
         }
-    }
-    LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ResourceRegistry());
-    return bundleResources;
-};
-ResourceRegistry.getResourceRegistrations = () => {
-    let resources = new Map();
-    for (let regis of ResourceRegistry.ResourceRegistrations) {
-        resources.set(regis[0], regis[1]);
-    }
-    return resources;
-};
-ResourceRegistry.ensureCorrectManifest = (manifest) => {
-    if (!manifest ||
-        !manifest.manifestType ||
-        manifest.manifestType !== Enums_1.ClientManifestTypes.Resource) {
-        throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as resource manifest. Mandatory properties maybe missing or the manifest is not of resource type");
-    }
-    manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
-};
+        LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ResourceRegistry());
+        return bundleResources;
+    }; }
+    static { this.getResourceRegistrations = () => {
+        let resources = new Map();
+        for (let regis of ResourceRegistry.ResourceRegistrations) {
+            resources.set(regis[0], regis[1]);
+        }
+        return resources;
+    }; }
+    static { this.ensureCorrectManifest = (manifest) => {
+        if (!manifest ||
+            !manifest.manifestType ||
+            manifest.manifestType !== Enums_1.ClientManifestTypes.Resource) {
+            throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as resource manifest. Mandatory properties maybe missing or the manifest is not of resource type");
+        }
+        manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
+    }; }
+}
+exports.ResourceRegistry = ResourceRegistry;

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

@@ -4,29 +4,29 @@ exports.SecurityProviderManifestRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
 const index_1 = require("./models/index");
 class SecurityProviderManifestRegistry {
+    static { this.SecurityProviders = []; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let result = [];
+        //Sanity check
+        for (let provider of SecurityProviderManifestRegistry.SecurityProviders) {
+            if (provider.type == index_1.SecurityProviderTypes.Combined &&
+                provider.securityProviderRules.length == 0) {
+                throw new Error("Can't specify a combined security provider without any dependencies to other providers: " + JSON.stringify(provider));
+            }
+        }
+        let securityProviderManifest = {
+            manifestType: index_1.ServerManifestTypes.SecurityProvider,
+            securityProviders: SecurityProviderManifestRegistry.SecurityProviders
+        };
+        result.push(securityProviderManifest);
+        return result;
+    }; }
+    static { this.AddSecurityProvider = (securityProvider) => {
+        SecurityProviderManifestRegistry.SecurityProviders.push(securityProvider);
+    }; }
+    static { this.clearState = () => {
+        SecurityProviderManifestRegistry.SecurityProviders = [];
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(SecurityProviderManifestRegistry.getServerManifests, SecurityProviderManifestRegistry.clearState)); }
 }
 exports.SecurityProviderManifestRegistry = SecurityProviderManifestRegistry;
-SecurityProviderManifestRegistry.SecurityProviders = [];
-SecurityProviderManifestRegistry.getServerManifests = (currentServiceId) => {
-    let result = [];
-    //Sanity check
-    for (let provider of SecurityProviderManifestRegistry.SecurityProviders) {
-        if (provider.type == index_1.SecurityProviderTypes.Combined &&
-            provider.securityProviderRules.length == 0) {
-            throw new Error("Can't specify a combined security provider without any dependencies to other providers: " + JSON.stringify(provider));
-        }
-    }
-    let securityProviderManifest = {
-        manifestType: index_1.ServerManifestTypes.SecurityProvider,
-        securityProviders: SecurityProviderManifestRegistry.SecurityProviders
-    };
-    result.push(securityProviderManifest);
-    return result;
-};
-SecurityProviderManifestRegistry.AddSecurityProvider = (securityProvider) => {
-    SecurityProviderManifestRegistry.SecurityProviders.push(securityProvider);
-};
-SecurityProviderManifestRegistry.clearState = () => {
-    SecurityProviderManifestRegistry.SecurityProviders = [];
-};
-SecurityProviderManifestRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(SecurityProviderManifestRegistry.getServerManifests, SecurityProviderManifestRegistry.clearState));

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

@@ -7,31 +7,31 @@ const ManifestRegistry_1 = require("./ManifestRegistry");
 const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class ServiceAppRegistry {
+    static { this.AddedAppDefinitions = {}; }
+    static { this.AddAppDefinition = (appDefinitionId, option) => {
+        if (appDefinitionId == models_1.Guid.empty) {
+            throw new Error("Can't add app definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        if (ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] != null) {
+            throw new Error("Can't add app definition id " + appDefinitionId + ", an app definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ServiceAppDefinition
+        };
+        let appManifest = (0, deep_extend_1.default)(manifest, option);
+        appManifest.uniqueId = appDefinitionId;
+        ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] = appManifest;
+    }; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        for (let key in ServiceAppRegistry.AddedAppDefinitions) {
+            serverManifests.push(ServiceAppRegistry.AddedAppDefinitions[key]);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        ServiceAppRegistry.AddedAppDefinitions = {};
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceAppRegistry.getServerManifests, ServiceAppRegistry.clearState)); }
 }
 exports.ServiceAppRegistry = ServiceAppRegistry;
-ServiceAppRegistry.AddedAppDefinitions = {};
-ServiceAppRegistry.AddAppDefinition = (appDefinitionId, option) => {
-    if (appDefinitionId == models_1.Guid.empty) {
-        throw new Error("Can't add app definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    if (ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] != null) {
-        throw new Error("Can't add app definition id " + appDefinitionId + ", an app definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ServiceAppDefinition
-    };
-    let appManifest = (0, deep_extend_1.default)(manifest, option);
-    appManifest.uniqueId = appDefinitionId;
-    ServiceAppRegistry.AddedAppDefinitions[appDefinitionId.toString()] = appManifest;
-};
-ServiceAppRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    for (let key in ServiceAppRegistry.AddedAppDefinitions) {
-        serverManifests.push(ServiceAppRegistry.AddedAppDefinitions[key]);
-    }
-    return serverManifests;
-};
-ServiceAppRegistry.clearState = () => {
-    ServiceAppRegistry.AddedAppDefinitions = {};
-};
-ServiceAppRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceAppRegistry.getServerManifests, ServiceAppRegistry.clearState));

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

@@ -8,32 +8,32 @@ const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 const AzureAdAppPermissionHelper_1 = require("./AzureAdAppPermissionHelper");
 class ServiceFeatureRegistry {
+    static { this.AddedFeatures = {}; }
+    static { this.AddFeature = (featureId, option) => {
+        if (featureId == models_1.Guid.empty) {
+            throw new Error("Can't add feature with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        if (ServiceFeatureRegistry.AddedFeatures[featureId.toString()] != null) {
+            throw new Error("Can't add feature id " + featureId + ", a feature with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ServiceFeature
+        };
+        let featureManifest = (0, deep_extend_1.default)(manifest, option);
+        featureManifest.uniqueId = featureId;
+        featureManifest.requiresAzureAdAppPermissions = AzureAdAppPermissionHelper_1.AzureAdAppPermissionHelper.getAzureAdAppPermissions(option.requiresAzureAdAppPermissions);
+        ServiceFeatureRegistry.AddedFeatures[featureId.toString()] = featureManifest;
+    }; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        for (let key in ServiceFeatureRegistry.AddedFeatures) {
+            serverManifests.push(ServiceFeatureRegistry.AddedFeatures[key]);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        ServiceFeatureRegistry.AddedFeatures = {};
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceFeatureRegistry.getServerManifests, ServiceFeatureRegistry.clearState)); }
 }
 exports.ServiceFeatureRegistry = ServiceFeatureRegistry;
-ServiceFeatureRegistry.AddedFeatures = {};
-ServiceFeatureRegistry.AddFeature = (featureId, option) => {
-    if (featureId == models_1.Guid.empty) {
-        throw new Error("Can't add feature with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    if (ServiceFeatureRegistry.AddedFeatures[featureId.toString()] != null) {
-        throw new Error("Can't add feature id " + featureId + ", a feature with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ServiceFeature
-    };
-    let featureManifest = (0, deep_extend_1.default)(manifest, option);
-    featureManifest.uniqueId = featureId;
-    featureManifest.requiresAzureAdAppPermissions = AzureAdAppPermissionHelper_1.AzureAdAppPermissionHelper.getAzureAdAppPermissions(option.requiresAzureAdAppPermissions);
-    ServiceFeatureRegistry.AddedFeatures[featureId.toString()] = featureManifest;
-};
-ServiceFeatureRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    for (let key in ServiceFeatureRegistry.AddedFeatures) {
-        serverManifests.push(ServiceFeatureRegistry.AddedFeatures[key]);
-    }
-    return serverManifests;
-};
-ServiceFeatureRegistry.clearState = () => {
-    ServiceFeatureRegistry.AddedFeatures = {};
-};
-ServiceFeatureRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceFeatureRegistry.getServerManifests, ServiceFeatureRegistry.clearState));

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

@@ -4,34 +4,34 @@ exports.ServiceManifestRegistry = void 0;
 const index_1 = require("./models/index");
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class ServiceManifestRegistry {
+    static { this.Service = null; }
+    static { this.AddService = (service) => {
+        if (!(service.serviceType === index_1.ServiceTypes.WebApp ||
+            service.serviceType === index_1.ServiceTypes.Worker ||
+            service.serviceType === index_1.ServiceTypes.Custom)) {
+            throw new Error("Unknown service type: " + JSON.stringify(service));
+        }
+        if (ServiceManifestRegistry.Service) {
+            throw new Error("Can't add more than one service in a project, service:  " + JSON.stringify(ServiceManifestRegistry.Service) + " already added.");
+        }
+        ServiceManifestRegistry.Service = service;
+    }; }
+    static { this.getServiceInfo = () => {
+        return ServiceManifestRegistry.Service;
+    }; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        if (ServiceManifestRegistry.Service != null) {
+            let serviceManifest = Object.assign({
+                manifestType: index_1.ServerManifestTypes.Service
+            }, ServiceManifestRegistry.Service);
+            serverManifests.push(serviceManifest);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        ServiceManifestRegistry.Service = null;
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceManifestRegistry.getServerManifests, ServiceManifestRegistry.clearState)); }
 }
 exports.ServiceManifestRegistry = ServiceManifestRegistry;
-ServiceManifestRegistry.Service = null;
-ServiceManifestRegistry.AddService = (service) => {
-    if (!(service.serviceType === index_1.ServiceTypes.WebApp ||
-        service.serviceType === index_1.ServiceTypes.Worker ||
-        service.serviceType === index_1.ServiceTypes.Custom)) {
-        throw new Error("Unknown service type: " + JSON.stringify(service));
-    }
-    if (ServiceManifestRegistry.Service) {
-        throw new Error("Can't add more than one service in a project, service:  " + JSON.stringify(ServiceManifestRegistry.Service) + " already added.");
-    }
-    ServiceManifestRegistry.Service = service;
-};
-ServiceManifestRegistry.getServiceInfo = () => {
-    return ServiceManifestRegistry.Service;
-};
-ServiceManifestRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    if (ServiceManifestRegistry.Service != null) {
-        let serviceManifest = Object.assign({
-            manifestType: index_1.ServerManifestTypes.Service
-        }, ServiceManifestRegistry.Service);
-        serverManifests.push(serviceManifest);
-    }
-    return serverManifests;
-};
-ServiceManifestRegistry.clearState = () => {
-    ServiceManifestRegistry.Service = null;
-};
-ServiceManifestRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceManifestRegistry.getServerManifests, ServiceManifestRegistry.clearState));

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

@@ -7,31 +7,31 @@ const ManifestRegistry_1 = require("./ManifestRegistry");
 const deep_extend_1 = tslib_1.__importDefault(require("deep-extend"));
 const models_1 = require("../../fx-models");
 class ServiceRoleRegistry {
+    static { this.AddedRoleDefinitions = {}; }
+    static { this.AddRoleDefinition = (roleDefinitionId, option) => {
+        if (roleDefinitionId == models_1.Guid.empty) {
+            throw new Error("Can't add role definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        if (ServiceRoleRegistry.AddedRoleDefinitions[roleDefinitionId.toString()] != null) {
+            throw new Error("Can't add role definition id " + roleDefinitionId + ", an role definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
+        }
+        let manifest = {
+            manifestType: index_1.ServerManifestTypes.ServiceRoleDefinition
+        };
+        let roleManifest = (0, deep_extend_1.default)(manifest, option);
+        roleManifest.uniqueId = roleDefinitionId;
+        ServiceRoleRegistry.AddedRoleDefinitions[roleDefinitionId.toString()] = roleManifest;
+    }; }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        for (let key in ServiceRoleRegistry.AddedRoleDefinitions) {
+            serverManifests.push(ServiceRoleRegistry.AddedRoleDefinitions[key]);
+        }
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        ServiceRoleRegistry.AddedRoleDefinitions = {};
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceRoleRegistry.getServerManifests, ServiceRoleRegistry.clearState)); }
 }
 exports.ServiceRoleRegistry = ServiceRoleRegistry;
-ServiceRoleRegistry.AddedRoleDefinitions = {};
-ServiceRoleRegistry.AddRoleDefinition = (roleDefinitionId, option) => {
-    if (roleDefinitionId == models_1.Guid.empty) {
-        throw new Error("Can't add role definition with id: Guid.empty. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    if (ServiceRoleRegistry.AddedRoleDefinitions[roleDefinitionId.toString()] != null) {
-        throw new Error("Can't add role definition id " + roleDefinitionId + ", an role definition with the same id has already been added. See manifest file: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    let manifest = {
-        manifestType: index_1.ServerManifestTypes.ServiceRoleDefinition
-    };
-    let roleManifest = (0, deep_extend_1.default)(manifest, option);
-    roleManifest.uniqueId = roleDefinitionId;
-    ServiceRoleRegistry.AddedRoleDefinitions[roleDefinitionId.toString()] = roleManifest;
-};
-ServiceRoleRegistry.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    for (let key in ServiceRoleRegistry.AddedRoleDefinitions) {
-        serverManifests.push(ServiceRoleRegistry.AddedRoleDefinitions[key]);
-    }
-    return serverManifests;
-};
-ServiceRoleRegistry.clearState = () => {
-    ServiceRoleRegistry.AddedRoleDefinitions = {};
-};
-ServiceRoleRegistry.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(ServiceRoleRegistry.getServerManifests, ServiceRoleRegistry.clearState));