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

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

@@ -1,5 +1,4 @@
 "use strict";
-var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LoadableManifestRegistry = exports.StaticClientLoadableManifestProviderProxy = void 0;
 //import { DomMatchingRule, LoadByUrlMatchingRule, LoadableBundleManifest, BundleIdentity } from './models';
@@ -75,268 +74,267 @@ class CircularDependencyValidator {
     }
 }
 class LoadableManifestRegistry {
-    static getManifestTargetName(target) {
-        switch (target.toString()) {
-            case models_1.ClientManifestTargetTypes.public.toString():
-                return "public";
-            case models_1.ClientManifestTargetTypes.admin.toString():
-                return "admin";
-            case models_1.ClientManifestTargetTypes.editor.toString():
-                return "editor";
-            case models_1.ClientManifestTargetTypes.docs.toString():
-                return "docs";
+    static { this.ManifestDependencies = new Map(); }
+    static { this.WithNoManifestDependencies = new Map(); }
+    static { this.ManifestFileTypes = new Map(); }
+    static { this.ManifestVersions = new Map(); }
+    static { this.ClientManifests = new Map(); }
+    static { this.RegisteredManifests = new Map(); }
+    static { this.ClientManifestProviders = []; }
+    static { this.getRegisteredManifest = (manifestId) => {
+        manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
+        return LoadableManifestRegistry.RegisteredManifests.get(manifestId);
+    }; }
+    static { this.withNoDependency = (manifestId) => {
+        manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
+        if (LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+            new Error("Can't combine adding dependencies and also set withNoDependency, see manifest path: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
-    }
-}
-exports.LoadableManifestRegistry = LoadableManifestRegistry;
-_a = LoadableManifestRegistry;
-LoadableManifestRegistry.ManifestDependencies = new Map();
-LoadableManifestRegistry.WithNoManifestDependencies = new Map();
-LoadableManifestRegistry.ManifestFileTypes = new Map();
-LoadableManifestRegistry.ManifestVersions = new Map();
-LoadableManifestRegistry.ClientManifests = new Map();
-LoadableManifestRegistry.RegisteredManifests = new Map();
-LoadableManifestRegistry.ClientManifestProviders = [];
-LoadableManifestRegistry.getRegisteredManifest = (manifestId) => {
-    manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
-    return _a.RegisteredManifests.get(manifestId);
-};
-LoadableManifestRegistry.withNoDependency = (manifestId) => {
-    manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
-    if (_a.ManifestDependencies.get(manifestId)) {
-        new Error("Can't combine adding dependencies and also set withNoDependency, see manifest path: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
-    }
-    _a.WithNoManifestDependencies.set(manifestId, true);
-};
-LoadableManifestRegistry.isDefineWithNoDependency = (manifestId) => {
-    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 (_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 (_a.ManifestDependencies.get(manifestId) == null) {
-        _a.ManifestDependencies.set(manifestId, []);
-    }
-    let alreadyAdded = false;
-    for (let currDep of _a.ManifestDependencies.get(manifestId)) {
-        if (currDep.manifestId.toString() === dependentOnManifestId.toString()) {
-            alreadyAdded = true;
-            break;
+        LoadableManifestRegistry.WithNoManifestDependencies.set(manifestId, true);
+    }; }
+    static { this.isDefineWithNoDependency = (manifestId) => {
+        return LoadableManifestRegistry.WithNoManifestDependencies.get(manifestId) === true;
+    }; }
+    static { this.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) {
+            new Error("Can't combine adding dependencies and also set withNoDependency, see manifest path: " + ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath());
         }
-    }
-    if (!alreadyAdded) {
-        _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 (!_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");
+        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, []);
+        }
+        let alreadyAdded = false;
+        for (let currDep of LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+            if (currDep.manifestId.toString() === dependentOnManifestId.toString()) {
+                alreadyAdded = true;
+                break;
             }
         }
-    }
-    else if (_a.ManifestDependencies.get(manifestId)) {
-        for (let dep of _a.ManifestDependencies.get(manifestId)) {
-            const bundleIdentity = {
-                resourceId: dep.manifestId
-            };
-            if (dep.externalOmniaServiceId) {
-                bundleIdentity.omniaServiceId = dep.externalOmniaServiceId;
+        if (!alreadyAdded) {
+            LoadableManifestRegistry.ManifestDependencies.get(manifestId).push(dependency);
+        }
+    }; }
+    static { this.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();
+            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");
+                }
             }
-            result.push(bundleIdentity);
         }
-    }
-    return result;
-};
-//This only seems to be used for detecting changes
-LoadableManifestRegistry.getAllManifestDependencies = () => {
-    const dependencies = new Map();
-    for (const regis of _a.ManifestDependencies) {
-        if (regis[1].length == 0 &&
-            _a.WithNoManifestDependencies.get(regis[0]) !== true) {
-            dependencies.set(regis[0], _a.getDefaultDependencies());
+        else if (LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+            for (let dep of LoadableManifestRegistry.ManifestDependencies.get(manifestId)) {
+                const bundleIdentity = {
+                    resourceId: dep.manifestId
+                };
+                if (dep.externalOmniaServiceId) {
+                    bundleIdentity.omniaServiceId = dep.externalOmniaServiceId;
+                }
+                result.push(bundleIdentity);
+            }
         }
-        else {
-            dependencies.set(regis[0], regis[1]);
+        return result;
+    }; }
+    //This only seems to be used for detecting changes
+    static { this.getAllManifestDependencies = () => {
+        const dependencies = new Map();
+        for (const regis of LoadableManifestRegistry.ManifestDependencies) {
+            if (regis[1].length == 0 &&
+                LoadableManifestRegistry.WithNoManifestDependencies.get(regis[0]) !== true) {
+                dependencies.set(regis[0], LoadableManifestRegistry.getDefaultDependencies());
+            }
+            else {
+                dependencies.set(regis[0], regis[1]);
+            }
         }
-    }
-    return dependencies;
-};
-LoadableManifestRegistry.addManifestVersion = (manifestId, type, version) => {
-    manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't add manifest version to manifest id null/empty/undefined.");
-    if (!version) {
-        throw new Error("Can't add manifest version null/empty/undefined to manifest id: " + manifestId);
-    }
-    if (!_a.ManifestVersions.get(manifestId)) {
-        _a.ManifestVersions.set(manifestId, {});
-    }
-    _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 = _a.ManifestVersions.get(manifestId);
-    if (!result) {
-        throw new Error(`Unexpected manifest ${manifestId}, build step has not set manifest version`);
-    }
-    return result;
-};
-LoadableManifestRegistry.addManifestBundleType = (manifestId, type) => {
-    manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't add manifest targetType to manifest id null/empty/undefined.");
-    if (_a.ManifestFileTypes.get(manifestId) == null) {
-        _a.ManifestFileTypes.set(manifestId, []);
-    }
-    let exists = false;
-    for (let t of _a.ManifestFileTypes.get(manifestId)) {
-        if (t === type) {
-            exists = true;
-            break;
+        return dependencies;
+    }; }
+    static { this.addManifestVersion = (manifestId, type, version) => {
+        manifestId = Utils_1.Utils.ensureValidManifestId(manifestId, "Can't add manifest version to manifest id null/empty/undefined.");
+        if (!version) {
+            throw new Error("Can't add manifest version null/empty/undefined to manifest id: " + manifestId);
         }
-    }
-    if (!exists) {
-        _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 = _a.ManifestFileTypes.get(manifestId);
-    if (!result ||
-        (result &&
-            result.length == 0)) {
-        console.log("Manifest BundleType has not been set, using JS for now, will generate error");
-        result = [Enums_1.BundleTargetTypes.Javascript];
-        //throw new Error("Unexpected state, no bundle target type's have been added to manifest id:" + manifestId + " during build");
-    }
-    return result;
-};
-LoadableManifestRegistry.registerManifest = (manifest) => {
-    if (!manifest ||
-        !manifest.manifestType ||
-        !manifest.resourceId) {
-        throw new Error("Unexpected state, loadable client manifest does not contain all mandatory attributes " + JSON.stringify(manifest));
-    }
-    manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
-    manifest.resourceName = manifest.resourceName;
-    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");
-    }
-    _a.ClientManifestProviders.push(provider);
-};
-LoadableManifestRegistry.getClientManifests = (currentServiceId) => {
-    if (!currentServiceId) {
-        throw new Error("Missing valid omnia service id");
-    }
-    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 = _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
-            _a.addClientManifest(currentServiceId, m);
+        if (!LoadableManifestRegistry.ManifestVersions.get(manifestId)) {
+            LoadableManifestRegistry.ManifestVersions.set(manifestId, {});
         }
-    }
-    _a.validateDependencies(currentServiceId);
-    for (const m of _a.ClientManifests.values()) {
-        manifests.push(m);
-    }
-    return manifests;
-};
-LoadableManifestRegistry.clearState = () => {
-    for (let provider of _a.ClientManifestProviders) {
-        provider.clearState();
-    }
-    _a.ClientManifests = new Map();
-    _a.ClientManifestProviders = [];
-    _a.ManifestDependencies = new Map();
-};
-LoadableManifestRegistry.validateDependencies = (currentServiceId) => {
-    for (let manifestIdWithDep of _a.ManifestDependencies.keys()) {
-        const clientManifestWithDep = _a.ClientManifests.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) {
-                    (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");
-                }
+        LoadableManifestRegistry.ManifestVersions.get(manifestId)[type] = version;
+    }; }
+    static { this.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);
+        if (!result) {
+            throw new Error(`Unexpected manifest ${manifestId}, build step has not set manifest version`);
+        }
+        return result;
+    }; }
+    static { this.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, []);
+        }
+        let exists = false;
+        for (let t of LoadableManifestRegistry.ManifestFileTypes.get(manifestId)) {
+            if (t === type) {
+                exists = true;
+                break;
             }
-            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) {
-                let groupManifest = <GroupedBundleManifest>LoadableManifestRegistry.ClientManifests[manifestIdWithDep];
-                
-                for (let manifestIdInGroup of groupManifest.manifestIdsInGroup) {
-
-                    try {
-                        new CircularDependencyValidator(LoadableManifestRegistry.ManifestDependencies,
-                            LoadableManifestRegistry.WithNoManifestDependencies,
-                            LoadableManifestRegistry.getDefaultDependencies(),
-                            manifestIdInGroup,
-                            dep);
-                    } catch (e) {
-                        throw new Error("Group manifest with id: " + manifestIdWithDep + " includes manifest with id: " + manifestIdInGroup + " which causes dependency error: " + e.toString());
+        }
+        if (!exists) {
+            LoadableManifestRegistry.ManifestFileTypes.get(manifestId).push(type);
+        }
+    }; }
+    static { this.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);
+        if (!result ||
+            (result &&
+                result.length == 0)) {
+            console.log("Manifest BundleType has not been set, using JS for now, will generate error");
+            result = [Enums_1.BundleTargetTypes.Javascript];
+            //throw new Error("Unexpected state, no bundle target type's have been added to manifest id:" + manifestId + " during build");
+        }
+        return result;
+    }; }
+    static { this.registerManifest = (manifest) => {
+        if (!manifest ||
+            !manifest.manifestType ||
+            !manifest.resourceId) {
+            throw new Error("Unexpected state, loadable client manifest does not contain all mandatory attributes " + JSON.stringify(manifest));
+        }
+        manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
+        manifest.resourceName = manifest.resourceName;
+        return LoadableManifestRegistry.RegisteredManifests.set(manifest.resourceId, manifest);
+    }; }
+    static { this.registerManifestProvider = (provider) => {
+        if (!provider) {
+            throw new Error("Unexpected state, loadable client manifest provider can't be null/undefined");
+        }
+        LoadableManifestRegistry.ClientManifestProviders.push(provider);
+    }; }
+    static { this.getClientManifests = (currentServiceId) => {
+        if (!currentServiceId) {
+            throw new Error("Missing valid omnia service id");
+        }
+        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];
+            let providerManifests = provider.getClientLoadableManifests(currentServiceId);
+            for (let m of providerManifests) {
+                //Check conflict etc
+                LoadableManifestRegistry.addClientManifest(currentServiceId, m);
+            }
+        }
+        LoadableManifestRegistry.validateDependencies(currentServiceId);
+        for (const m of LoadableManifestRegistry.ClientManifests.values()) {
+            manifests.push(m);
+        }
+        return manifests;
+    }; }
+    static { this.clearState = () => {
+        for (let provider of LoadableManifestRegistry.ClientManifestProviders) {
+            provider.clearState();
+        }
+        LoadableManifestRegistry.ClientManifests = new Map();
+        LoadableManifestRegistry.ClientManifestProviders = [];
+        LoadableManifestRegistry.ManifestDependencies = new Map();
+    }; }
+    static { this.validateDependencies = (currentServiceId) => {
+        for (let manifestIdWithDep of LoadableManifestRegistry.ManifestDependencies.keys()) {
+            const clientManifestWithDep = this.ClientManifests.get(manifestIdWithDep);
+            for (let dep of LoadableManifestRegistry.ManifestDependencies.get(manifestIdWithDep)) {
+                if (dep.externalOmniaServiceId == null) {
+                    const manifestDependency = this.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) {
+                        (0, tooling_1.log)(`Manifest: ${manifestIdWithDep} with target ${this.getManifestTargetName(clientManifestWithDep.target)} has dependency to ${dep.manifestId} with target ${this.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);
+                /* 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) {
+                    let groupManifest = <GroupedBundleManifest>LoadableManifestRegistry.ClientManifests[manifestIdWithDep];
+                    
+                    for (let manifestIdInGroup of groupManifest.manifestIdsInGroup) {
+
+                        try {
+                            new CircularDependencyValidator(LoadableManifestRegistry.ManifestDependencies,
+                                LoadableManifestRegistry.WithNoManifestDependencies,
+                                LoadableManifestRegistry.getDefaultDependencies(),
+                                manifestIdInGroup,
+                                dep);
+                        } catch (e) {
+                            throw new Error("Group manifest with id: " + manifestIdWithDep + " includes manifest with id: " + manifestIdInGroup + " which causes dependency error: " + e.toString());
+                        }
 
+                    }
+                }*/
+                if (dep.externalOmniaServiceId != null &&
+                    dep.externalOmniaServiceId === 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) {
+                    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.");
                 }
-            }*/
-            if (dep.externalOmniaServiceId != null &&
-                dep.externalOmniaServiceId === 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 &&
-                _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.");
             }
         }
+    }; }
+    static { this.addClientManifest = (omniaServiceId, manifest) => {
+        if (!manifest) {
+            throw new Error("Unexpected state, client manifest null cant't be added as client side manifest");
+        }
+        if (!manifest.resourceId) {
+            throw new Error("Unexpected state, client manifest resourceId cant't be null/empty/undefined");
+        }
+        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) {
+            throw new Error("Unexpected state, client manifest id's should be unique and added once. Already added: "
+                + JSON.stringify(LoadableManifestRegistry.ClientManifests.get(manifest.resourceId))
+                + " trying to add: " +
+                JSON.stringify(manifest));
+        }
+        LoadableManifestRegistry.ClientManifests.set(manifest.resourceId, manifest);
+    }; }
+    static getManifestTargetName(target) {
+        switch (target.toString()) {
+            case models_1.ClientManifestTargetTypes.public.toString():
+                return "public";
+            case models_1.ClientManifestTargetTypes.admin.toString():
+                return "admin";
+            case models_1.ClientManifestTargetTypes.editor.toString():
+                return "editor";
+            case models_1.ClientManifestTargetTypes.docs.toString():
+                return "docs";
+        }
     }
-};
-LoadableManifestRegistry.addClientManifest = (omniaServiceId, manifest) => {
-    if (!manifest) {
-        throw new Error("Unexpected state, client manifest null cant't be added as client side manifest");
-    }
-    if (!manifest.resourceId) {
-        throw new Error("Unexpected state, client manifest resourceId cant't be null/empty/undefined");
-    }
-    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 (_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(_a.ClientManifests.get(manifest.resourceId))
-            + " trying to add: " +
-            JSON.stringify(manifest));
-    }
-    _a.ClientManifests.set(manifest.resourceId, manifest);
-};
-LoadableManifestRegistry.getDefaultDependencies = () => {
-    return [
-    /// <<optimize manifest.json smaller>> try to remove this hard code
-    // {
-    //     omniaServiceId: 'bb000000-0000-bbbb-0000-0000000000bb',
-    //     resourceId: OmniaResourceManifests.FxUx.toString()
-    // }
-    ];
-};
-//Just dummy to register subscriber
-LoadableManifestRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(_a.getClientManifests, _a.clearState));
+    static { this.getDefaultDependencies = () => {
+        return [
+        /// <<optimize manifest.json smaller>> try to remove this hard code
+        // {
+        //     omniaServiceId: 'bb000000-0000-bbbb-0000-0000000000bb',
+        //     resourceId: OmniaResourceManifests.FxUx.toString()
+        // }
+        ];
+    }; }
+    //Just dummy to register subscriber
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(LoadableManifestRegistry.getClientManifests, LoadableManifestRegistry.clearState)); }
+}
+exports.LoadableManifestRegistry = LoadableManifestRegistry;

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

@@ -19,6 +19,7 @@ function getLocalizationPath(exp, ns) {
 }
 exports.getLocalizationPath = getLocalizationPath;
 class Localization {
+    static { this.localizationRegistrations = []; }
     constructor(localizationOptions, manifestId) {
         this.target = models_1.LocalizationTargetTypes.public;
         this.namespace = (name) => {
@@ -48,23 +49,22 @@ class Localization {
         this.target = target;
         return this;
     }
+    static { this.getRegistrations = () => {
+        return Localization.localizationRegistrations;
+    }; }
+    static { this.clearRegistrations = () => {
+        Localization.localizationRegistrations = [];
+    }; }
+    static { this.getClientManifests = (currentServiceId) => {
+        let result = [];
+        return result;
+    }; }
+    static { this.clearState = () => {
+        _localizations = {};
+    }; }
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(Localization.getClientManifests, Localization.clearState)); }
 }
 exports.Localization = Localization;
-Localization.localizationRegistrations = [];
-Localization.getRegistrations = () => {
-    return Localization.localizationRegistrations;
-};
-Localization.clearRegistrations = () => {
-    Localization.localizationRegistrations = [];
-};
-Localization.getClientManifests = (currentServiceId) => {
-    let result = [];
-    return result;
-};
-Localization.clearState = () => {
-    _localizations = {};
-};
-Localization.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(Localization.getClientManifests, Localization.clearState));
 class LocalizationNamespaceComposer {
     constructor(root, manifestId) {
         this.add = (localizeObject) => {