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

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

@@ -17,38 +17,38 @@ class BlockInformation {
 //    omniaServiceId: string;
 //}
 class BlockingRegistry {
+    static { this.BlockedManifests = []; }
+    static { this.addBlockedManifest = (omniaServiceId, manifestId) => {
+        omniaServiceId = Utils_1.Utils.ensureValidServiceId(omniaServiceId);
+        manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
+        BlockingRegistry.BlockedManifests.push(new BlockInformation({
+            omniaServiceId: omniaServiceId,
+            resourceId: manifestId,
+            manifestType: Enums_1.ClientManifestTypes.BlockedManifest
+        }, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath()));
+    }; }
+    //public static addBlockedElementName = (omniaServiceId: string, elementName: string) => {
+    //    omniaServiceId = Utils.ensureValidOmniaServiceId(omniaServiceId);
+    //    elementName = Utils.ensureValidElementName(elementName);
+    //    BlockingRegistry.BlockedManifests.push({
+    //        omniaServiceId: omniaServiceId,
+    //        resourceId: manifestId,
+    //        manifestType: ManifestType.BlockedManifest
+    //    });
+    //}
+    static { this.getClientManifests = (currentServiceId) => {
+        let result = [];
+        for (let b of BlockingRegistry.BlockedManifests) {
+            if (b.blockedManifest.omniaServiceId === currentServiceId) {
+                throw new Error("It's not allowed to block manifests in the current omnia service (only external), see manifest file:" + b.manifestPath);
+            }
+            result.push(b.blockedManifest);
+        }
+        return result;
+    }; }
+    static { this.clearState = () => {
+        BlockingRegistry.BlockedManifests = [];
+    }; }
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BlockingRegistry.getClientManifests, BlockingRegistry.clearState)); }
 }
 exports.BlockingRegistry = BlockingRegistry;
-BlockingRegistry.BlockedManifests = [];
-BlockingRegistry.addBlockedManifest = (omniaServiceId, manifestId) => {
-    omniaServiceId = Utils_1.Utils.ensureValidServiceId(omniaServiceId);
-    manifestId = Utils_1.Utils.ensureValidManifestId(manifestId);
-    BlockingRegistry.BlockedManifests.push(new BlockInformation({
-        omniaServiceId: omniaServiceId,
-        resourceId: manifestId,
-        manifestType: Enums_1.ClientManifestTypes.BlockedManifest
-    }, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath()));
-};
-//public static addBlockedElementName = (omniaServiceId: string, elementName: string) => {
-//    omniaServiceId = Utils.ensureValidOmniaServiceId(omniaServiceId);
-//    elementName = Utils.ensureValidElementName(elementName);
-//    BlockingRegistry.BlockedManifests.push({
-//        omniaServiceId: omniaServiceId,
-//        resourceId: manifestId,
-//        manifestType: ManifestType.BlockedManifest
-//    });
-//}
-BlockingRegistry.getClientManifests = (currentServiceId) => {
-    let result = [];
-    for (let b of BlockingRegistry.BlockedManifests) {
-        if (b.blockedManifest.omniaServiceId === currentServiceId) {
-            throw new Error("It's not allowed to block manifests in the current omnia service (only external), see manifest file:" + b.manifestPath);
-        }
-        result.push(b.blockedManifest);
-    }
-    return result;
-};
-BlockingRegistry.clearState = () => {
-    BlockingRegistry.BlockedManifests = [];
-};
-BlockingRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BlockingRegistry.getClientManifests, BlockingRegistry.clearState));

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

@@ -3,24 +3,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BuildConfigurationRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class BuildConfigurationRegistry {
+    static { this.BuildOptions = null; }
+    static { this.AddBuildOptions = (buildOptions) => {
+        BuildConfigurationRegistry.BuildOptions = buildOptions;
+    }; }
+    static { this.getBuildOptions = () => {
+        //let defaultOptions: BuildOptions = {
+        //    moduleOptions: {},
+        //    bundleOptions: {}
+        //};
+        //BuildConfigurationRegistry.BuildOptions = deepExtend(defaultOptions, BuildConfigurationRegistry.BuildOptions);
+        return BuildConfigurationRegistry.BuildOptions;
+    }; }
+    static { this.getClientManifests = (currentServiceId) => {
+        return new Array();
+    }; }
+    static { this.clearState = () => {
+        BuildConfigurationRegistry.BuildOptions = null;
+    }; }
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BuildConfigurationRegistry.getClientManifests, BuildConfigurationRegistry.clearState)); }
 }
 exports.BuildConfigurationRegistry = BuildConfigurationRegistry;
-BuildConfigurationRegistry.BuildOptions = null;
-BuildConfigurationRegistry.AddBuildOptions = (buildOptions) => {
-    BuildConfigurationRegistry.BuildOptions = buildOptions;
-};
-BuildConfigurationRegistry.getBuildOptions = () => {
-    //let defaultOptions: BuildOptions = {
-    //    moduleOptions: {},
-    //    bundleOptions: {}
-    //};
-    //BuildConfigurationRegistry.BuildOptions = deepExtend(defaultOptions, BuildConfigurationRegistry.BuildOptions);
-    return BuildConfigurationRegistry.BuildOptions;
-};
-BuildConfigurationRegistry.getClientManifests = (currentServiceId) => {
-    return new Array();
-};
-BuildConfigurationRegistry.clearState = () => {
-    BuildConfigurationRegistry.BuildOptions = null;
-};
-BuildConfigurationRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(BuildConfigurationRegistry.getClientManifests, BuildConfigurationRegistry.clearState));

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

@@ -71,92 +71,92 @@ class ComponentRegistry {
             ComponentRegistry.ComponentRegistrations = new Map();
         };
     }
-}
-exports.ComponentRegistry = ComponentRegistry;
-ComponentRegistry.ComponentRegistrations = new Map();
-ComponentRegistry.ComponentElements = {};
-ComponentRegistry.registerComponent = (manifest, componentOptions) => {
-    ComponentRegistry.ensureCorrectManifest(manifest);
-    if (!componentOptions) {
-        throw new Error("Can't register component with missing componentOptions");
-    }
-    if (!componentOptions.elementName ||
-        !componentOptions.entryPoint) {
-        throw new Error("Can't register component with missing mandatory attributes: " + JSON.stringify(componentOptions));
-    }
-    if (ComponentRegistry.ComponentRegistrations.get(manifest.resourceId)) {
-        throw new Error("Can't re-register component on manifest with id: " + manifest.resourceId +
-            " current info: " + JSON.stringify(ComponentRegistry.ComponentRegistrations.get(manifest.resourceId)));
-    }
-    if (ComponentRegistry.ComponentElements[componentOptions.elementName]) {
-        throw new Error("Can't register component: " + JSON.stringify(componentOptions) + " elementName is already registered");
-    }
-    try {
-        ComponentRegistry.ComponentElements[componentOptions.elementName] = true;
-        ComponentRegistry.ComponentRegistrations.set(manifest.resourceId, new ComponentRegistration(componentOptions, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
-    }
-    catch (e) {
-        ComponentRegistry.ComponentElements[componentOptions.elementName] = false;
-        ComponentRegistry.ComponentRegistrations.set(manifest.resourceId, null);
-    }
-};
-ComponentRegistry.getComponentDefinition = (manifest) => {
-    ComponentRegistry.ensureCorrectManifest(manifest);
-    let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
-    if (registration != null) {
-        return registration.definition;
-    }
-    return null;
-};
-ComponentRegistry.addComponentDefinition = (manifest, definition) => {
-    ComponentRegistry.ensureCorrectManifest(manifest);
-    let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
-    if (registration != null) {
-        registration.definition = definition;
-    }
-    else {
-        throw new Error("Can't add ComponentDefinition for component manifest with id: " + manifest.resourceId + " a component has not been registered");
-    }
-};
-ComponentRegistry.addComponentBuildOptions = (manifest, buildOptions) => {
-    ComponentRegistry.ensureCorrectManifest(manifest);
-    let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
-    if (registration != null) {
-        registration.buildOptions = buildOptions;
-    }
-    else {
-        throw new Error("Can't add buildOptions for component manifest with id: " + manifest.resourceId + " a component has not been registered");
-    }
-};
-ComponentRegistry.newCombinedRules = (manifest, rules) => {
-    if (rules) {
+    static { this.ComponentRegistrations = new Map(); }
+    static { this.ComponentElements = {}; }
+    static { this.registerComponent = (manifest, componentOptions) => {
+        ComponentRegistry.ensureCorrectManifest(manifest);
+        if (!componentOptions) {
+            throw new Error("Can't register component with missing componentOptions");
+        }
+        if (!componentOptions.elementName ||
+            !componentOptions.entryPoint) {
+            throw new Error("Can't register component with missing mandatory attributes: " + JSON.stringify(componentOptions));
+        }
+        if (ComponentRegistry.ComponentRegistrations.get(manifest.resourceId)) {
+            throw new Error("Can't re-register component on manifest with id: " + manifest.resourceId +
+                " current info: " + JSON.stringify(ComponentRegistry.ComponentRegistrations.get(manifest.resourceId)));
+        }
+        if (ComponentRegistry.ComponentElements[componentOptions.elementName]) {
+            throw new Error("Can't register component: " + JSON.stringify(componentOptions) + " elementName is already registered");
+        }
+        try {
+            ComponentRegistry.ComponentElements[componentOptions.elementName] = true;
+            ComponentRegistry.ComponentRegistrations.set(manifest.resourceId, new ComponentRegistration(componentOptions, ManifestRegistry_1.ManifestRegistry.getCurrentManifestPath(), manifest));
+        }
+        catch (e) {
+            ComponentRegistry.ComponentElements[componentOptions.elementName] = false;
+            ComponentRegistry.ComponentRegistrations.set(manifest.resourceId, null);
+        }
+    }; }
+    static { this.getComponentDefinition = (manifest) => {
         ComponentRegistry.ensureCorrectManifest(manifest);
-        Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
         let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
         if (registration != null) {
-            registration.loadRules = rules;
+            return registration.definition;
+        }
+        return null;
+    }; }
+    static { this.addComponentDefinition = (manifest, definition) => {
+        ComponentRegistry.ensureCorrectManifest(manifest);
+        let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
+        if (registration != null) {
+            registration.definition = definition;
         }
         else {
-            throw new Error("Can't add load rules for component manifest with id: " + manifest.resourceId + " a component has not been registered");
+            throw new Error("Can't add ComponentDefinition for component manifest with id: " + manifest.resourceId + " a component has not been registered");
         }
-    }
-};
-ComponentRegistry.getRegistrations = () => {
-    let components = [];
-    for (const wc of ComponentRegistry.ComponentRegistrations.values()) {
-        components.push(wc);
-    }
-    LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ComponentRegistry());
-    return components;
-};
-ComponentRegistry.getComponentRegistrations = () => {
-    return Array.from(ComponentRegistry.ComponentRegistrations.values());
-};
-ComponentRegistry.ensureCorrectManifest = (manifest) => {
-    if (!manifest ||
-        !manifest.manifestType ||
-        manifest.manifestType !== Enums_1.ClientManifestTypes.Component) {
-        throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as component manifest. Mandatory properties maybe missing or the manifest is not of component type");
-    }
-    manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
-};
+    }; }
+    static { this.addComponentBuildOptions = (manifest, buildOptions) => {
+        ComponentRegistry.ensureCorrectManifest(manifest);
+        let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
+        if (registration != null) {
+            registration.buildOptions = buildOptions;
+        }
+        else {
+            throw new Error("Can't add buildOptions for component manifest with id: " + manifest.resourceId + " a component has not been registered");
+        }
+    }; }
+    static { this.newCombinedRules = (manifest, rules) => {
+        if (rules) {
+            ComponentRegistry.ensureCorrectManifest(manifest);
+            Utils_1.Utils.validateSupportedLoadRuleTypes(rules);
+            let registration = ComponentRegistry.ComponentRegistrations.get(manifest.resourceId);
+            if (registration != null) {
+                registration.loadRules = rules;
+            }
+            else {
+                throw new Error("Can't add load rules for component manifest with id: " + manifest.resourceId + " a component has not been registered");
+            }
+        }
+    }; }
+    static { this.getRegistrations = () => {
+        let components = [];
+        for (const wc of ComponentRegistry.ComponentRegistrations.values()) {
+            components.push(wc);
+        }
+        LoadableManifestRegistry_1.LoadableManifestRegistry.registerManifestProvider(new ComponentRegistry());
+        return components;
+    }; }
+    static { this.getComponentRegistrations = () => {
+        return Array.from(ComponentRegistry.ComponentRegistrations.values());
+    }; }
+    static { this.ensureCorrectManifest = (manifest) => {
+        if (!manifest ||
+            !manifest.manifestType ||
+            manifest.manifestType !== Enums_1.ClientManifestTypes.Component) {
+            throw new Error("Manifest :" + JSON.stringify(manifest) + " can't be used as component manifest. Mandatory properties maybe missing or the manifest is not of component type");
+        }
+        manifest.resourceId = Utils_1.Utils.ensureValidManifestId(manifest.resourceId);
+    }; }
+}
+exports.ComponentRegistry = ComponentRegistry;

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

@@ -56,41 +56,41 @@ class Composer {
     */
     constructor() {
     }
+    /**
+    * Registers a new manifest
+    * @param manifestId the unique id of the manifest, must be a valid guid.
+    * @param name a friendly name of the manifest.
+    */
+    static { this.registerManifest = (manifestId, name) => {
+        return new NewManifestComposer(manifestId.toString(), name);
+    }; }
+    /**
+    * Re-opens resources manifest, so more resources can be included.
+    * {param}:manifestId the unique id of the resource manifest to open, must be a valid guid.
+    */
+    static { this.openResourceManifest = (manifestId) => {
+        return new ResourcesComposer_1.ReOpenedResourceComposer(manifestId.toString());
+    }; }
     /** Add information about things you want to block.
         E.g. block a manifest from being loaded, so you can provide your own implementation
     */
     static get block() {
         return new BlockingComposer_1.BlockingComposer();
     }
+    static { this.importManifests = (folderPath) => {
+        ImportManifestRegistry_1.ImportManifestRegistry.add(folderPath);
+        return {
+            configuration: (omniaServiceId, configurationType) => {
+                return _1.ConfigurationClientServiceRegistry.Add(omniaServiceId, configurationType, [Composer]);
+            },
+            done: () => {
+                return {
+                    registerManifest: Composer.registerManifest,
+                    openResourceManifest: Composer.openResourceManifest,
+                    block: Composer.block
+                };
+            }
+        };
+    }; }
 }
 exports.Composer = Composer;
-/**
-* Registers a new manifest
-* @param manifestId the unique id of the manifest, must be a valid guid.
-* @param name a friendly name of the manifest.
-*/
-Composer.registerManifest = (manifestId, name) => {
-    return new NewManifestComposer(manifestId.toString(), name);
-};
-/**
-* Re-opens resources manifest, so more resources can be included.
-* {param}:manifestId the unique id of the resource manifest to open, must be a valid guid.
-*/
-Composer.openResourceManifest = (manifestId) => {
-    return new ResourcesComposer_1.ReOpenedResourceComposer(manifestId.toString());
-};
-Composer.importManifests = (folderPath) => {
-    ImportManifestRegistry_1.ImportManifestRegistry.add(folderPath);
-    return {
-        configuration: (omniaServiceId, configurationType) => {
-            return _1.ConfigurationClientServiceRegistry.Add(omniaServiceId, configurationType, [Composer]);
-        },
-        done: () => {
-            return {
-                registerManifest: Composer.registerManifest,
-                openResourceManifest: Composer.openResourceManifest,
-                block: Composer.block
-            };
-        }
-    };
-};

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

@@ -48,6 +48,7 @@ class OmniaFxConfigurator {
 }
 exports.OmniaFxConfigurator = OmniaFxConfigurator;
 class ConfigurationClientServiceRegistry {
+    static { this.configurations = {}; }
     static Add(omniaServiceId, configurationType, constructorArgs) {
         let creator = function construct(constructor, args) {
             function F() {
@@ -67,20 +68,19 @@ class ConfigurationClientServiceRegistry {
     static getConfigurations() {
         return ConfigurationClientServiceRegistry.configurations;
     }
+    static { this.getClientManifests = (currentServiceId) => {
+        let result = new Array();
+        let configuration = ConfigurationClientServiceRegistry.configurations[currentServiceId.toLowerCase()];
+        if (configuration) {
+            result.push(Object.assign({}, configuration.build(), {
+                manifestType: models_1.ClientManifestTypes.Configuration
+            }));
+        }
+        return result;
+    }; }
+    static { this.clearState = () => {
+        ConfigurationClientServiceRegistry.configurations = {};
+    }; }
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ConfigurationClientServiceRegistry.getClientManifests, ConfigurationClientServiceRegistry.clearState)); }
 }
 exports.ConfigurationClientServiceRegistry = ConfigurationClientServiceRegistry;
-ConfigurationClientServiceRegistry.configurations = {};
-ConfigurationClientServiceRegistry.getClientManifests = (currentServiceId) => {
-    let result = new Array();
-    let configuration = ConfigurationClientServiceRegistry.configurations[currentServiceId.toLowerCase()];
-    if (configuration) {
-        result.push(Object.assign({}, configuration.build(), {
-            manifestType: models_1.ClientManifestTypes.Configuration
-        }));
-    }
-    return result;
-};
-ConfigurationClientServiceRegistry.clearState = () => {
-    ConfigurationClientServiceRegistry.configurations = {};
-};
-ConfigurationClientServiceRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ConfigurationClientServiceRegistry.getClientManifests, ConfigurationClientServiceRegistry.clearState));

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

@@ -25,13 +25,13 @@ class DevelopmentBuildConfiguration {
     static get isEnableMeasureBuild() {
         return DevelopmentBuildConfiguration._enableMeasureBuild;
     }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        DevelopmentBuildConfiguration._disableBuild = false;
+    }; }
+    static { this.clientSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentBuildConfiguration.getServerManifests, DevelopmentBuildConfiguration.clearState)); }
 }
 exports.DevelopmentBuildConfiguration = DevelopmentBuildConfiguration;
-DevelopmentBuildConfiguration.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    return serverManifests;
-};
-DevelopmentBuildConfiguration.clearState = () => {
-    DevelopmentBuildConfiguration._disableBuild = false;
-};
-DevelopmentBuildConfiguration.clientSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentBuildConfiguration.getServerManifests, DevelopmentBuildConfiguration.clearState));

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

@@ -19,11 +19,11 @@ class DevelopmentEnvironment {
     get hosting() {
         return new DevelopmentHostingEnvironment_1.DevelopmentHostingEnvironment(this.localOverride);
     }
+    static { this.localOverride = () => {
+        return new DevelopmentEnvironment(true);
+    }; }
     get build() {
         return new DevelopmentBuildConfiguration_1.DevelopmentBuildConfiguration();
     }
 }
 exports.DevelopmentEnvironment = DevelopmentEnvironment;
-DevelopmentEnvironment.localOverride = () => {
-    return new DevelopmentEnvironment(true);
-};

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

@@ -75,13 +75,13 @@ class DevelopmentHostingEnvironment {
             }
         };
     }
+    static { this.getServerManifests = (currentServiceId) => {
+        let serverManifests = new Array();
+        return serverManifests;
+    }; }
+    static { this.clearState = () => {
+        devHosting = null;
+    }; }
+    static { this.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentHostingEnvironment.getServerManifests, DevelopmentHostingEnvironment.clearState)); }
 }
 exports.DevelopmentHostingEnvironment = DevelopmentHostingEnvironment;
-DevelopmentHostingEnvironment.getServerManifests = (currentServiceId) => {
-    let serverManifests = new Array();
-    return serverManifests;
-};
-DevelopmentHostingEnvironment.clearState = () => {
-    devHosting = null;
-};
-DevelopmentHostingEnvironment.ServerSubscription = ManifestRegistry_1.ManifestRegistry.registerServerManifestProvider(new ManifestRegistry_1.StaticServerManifestProviderProxy(DevelopmentHostingEnvironment.getServerManifests, DevelopmentHostingEnvironment.clearState));

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

@@ -3,23 +3,23 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ImportManifestRegistry = void 0;
 const ManifestRegistry_1 = require("./ManifestRegistry");
 class ImportManifestRegistry {
+    static { this.manifestPackagePaths = []; }
+    static { this.add = (path) => {
+        // use Set to filter duplicate
+        if (ImportManifestRegistry.manifestPackagePaths.indexOf(path) > -1) {
+            throw new Error(`Error, already import manifest with path ${path}`);
+        }
+        ImportManifestRegistry.manifestPackagePaths.push(path);
+    }; }
+    static { this.getPaths = () => {
+        return [...ImportManifestRegistry.manifestPackagePaths];
+    }; }
+    static { this.getClientManifests = (currentServiceId) => {
+        return new Array();
+    }; }
+    static { this.clearState = () => {
+        ImportManifestRegistry.manifestPackagePaths = [];
+    }; }
+    static { this.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ImportManifestRegistry.getClientManifests, ImportManifestRegistry.clearState)); }
 }
 exports.ImportManifestRegistry = ImportManifestRegistry;
-ImportManifestRegistry.manifestPackagePaths = [];
-ImportManifestRegistry.add = (path) => {
-    // use Set to filter duplicate
-    if (ImportManifestRegistry.manifestPackagePaths.indexOf(path) > -1) {
-        throw new Error(`Error, already import manifest with path ${path}`);
-    }
-    ImportManifestRegistry.manifestPackagePaths.push(path);
-};
-ImportManifestRegistry.getPaths = () => {
-    return [...ImportManifestRegistry.manifestPackagePaths];
-};
-ImportManifestRegistry.getClientManifests = (currentServiceId) => {
-    return new Array();
-};
-ImportManifestRegistry.clearState = () => {
-    ImportManifestRegistry.manifestPackagePaths = [];
-};
-ImportManifestRegistry.Subscription = ManifestRegistry_1.ManifestRegistry.registerClientManifestProvider(new ManifestRegistry_1.StaticClientManifestProviderProxy(ImportManifestRegistry.getClientManifests, ImportManifestRegistry.clearState));