@combeenation/3d-viewer 5.0.1 → 5.0.3-beta2

package/dist/lib-cjs/api/manager/variantInstanceManager.js

@@ -1,336 +1,336 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariantInstanceManager = void 0;
-var tslib_1 = require("tslib");
-var lodash_es_1 = require("lodash-es");
-var dottedPath_1 = require("../classes/dottedPath");
-var event_1 = require("../classes/event");
-var eventBroadcaster_1 = require("../classes/eventBroadcaster");
-var parameter_1 = require("../classes/parameter");
-var variantInstance_1 = require("../classes/variantInstance");
-/**
- * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
- * {@link Viewer} instance via its {@link Viewer.variantInstances}
- */
-var VariantInstanceManager = /** @class */ (function (_super) {
-    tslib_1.__extends(VariantInstanceManager, _super);
-    /**
-     * Constructor.
-     */
-    function VariantInstanceManager(rootVariant) {
-        var _this = _super.call(this) || this;
-        _this.rootVariant = rootVariant;
-        _this.variantInstancePromises = new Map();
-        _this.variantInstances = new Map();
-        _this.variantInstanceDefinitions = new Map();
-        _this.parameters = {};
-        _this.queues = {};
-        return _this;
-    }
-    /**
-     * Creates a {@link VariantInstanceManager} based on given root Variant.
-     */
-    VariantInstanceManager.create = function (rootVariant) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            return tslib_1.__generator(this, function (_a) {
-                return [2 /*return*/, new VariantInstanceManager(rootVariant)];
-            });
-        });
-    };
-    Object.defineProperty(VariantInstanceManager.prototype, "all", {
-        /**
-         * Gets all instances.
-         */
-        get: function () {
-            var all = [];
-            this.variantInstances.forEach(function (variantInstance) { return all.push(variantInstance); });
-            return all;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(VariantInstanceManager.prototype, "allDefinitions", {
-        /**
-         * Gets all instance definitions.
-         */
-        get: function () {
-            var all = [];
-            this.variantInstanceDefinitions.forEach(function (definition) { return all.push(definition); });
-            return all;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    /**
-     * Checks whether a {@link VariantInstance} is either registered or created.
-     */
-    VariantInstanceManager.prototype.has = function (name) {
-        return this.variantInstances.has(name) || this.variantInstanceDefinitions.has(name);
-    };
-    /**
-     * Retrieves a {@link VariantInstance}.
-     * If the instance has been created, the created instance will be returned.
-     * If the instance is registered, the instance will be created and returned.
-     * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
-     * If none of these apply, an Error is thrown.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    VariantInstanceManager.prototype.get = function (name) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var definition, vip;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                // 1) see if we have an instance of that name already and return it if found
-                if (this.variantInstances.has(name)) {
-                    return [2 /*return*/, this.variantInstances.get(name)]; // cannot be null, hence the exclamation mark
-                }
-                // 2) try to get promise from list of requested instances and return it if found
-                if (this.variantInstancePromises.has(name)) {
-                    return [2 /*return*/, this.variantInstancePromises.get(name)];
-                }
-                // 3) see if there's a definition of that name, create an instance from it and store the related promise
-                if (this.variantInstanceDefinitions.has(name)) {
-                    definition = this.variantInstanceDefinitions.get(name);
-                    vip = this.createFromDefinition(definition);
-                    this.variantInstancePromises.set(name, vip);
-                    // remove promise after it has been finished
-                    vip.then(function () { return _this.variantInstancePromises.delete(name); });
-                    return [2 /*return*/, vip];
-                }
-                //* if we are here, no instance definition of that name exists. throw error.
-                throw Error("VariantInstance with name \"" + name + "\" neither created nor configured.");
-            });
-        });
-    };
-    /**
-     * Creates and registers a unique {@link VariantInstance}.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    VariantInstanceManager.prototype.create = function (dottedPath, name, parameters) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var variant, definition;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        variant = dottedPath_1.DottedPath.create(dottedPath).path;
-                        definition = {
-                            name: this.ensureUniqueName(name ? name : variant),
-                            variant: variant,
-                            parameters: parameters,
-                        };
-                        return [4 /*yield*/, this.createFromDefinition(definition)];
-                    case 1: return [2 /*return*/, _a.sent()];
-                }
-            });
-        });
-    };
-    /**
-     * Registers a unique {@link VariantInstanceDefinition}.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
-     */
-    VariantInstanceManager.prototype.register = function (instanceDefinition) {
-        var name = instanceDefinition.name ? instanceDefinition.name : dottedPath_1.DottedPath.create(instanceDefinition.variant).path;
-        instanceDefinition.name = this.ensureUniqueName(name);
-        this.variantInstanceDefinitions.set(instanceDefinition.name, instanceDefinition);
-        this.broadcastEvent(event_1.Event.VARIANT_INSTANCE_REGISTERED, instanceDefinition);
-        return instanceDefinition;
-    };
-    /**
-     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
-     */
-    VariantInstanceManager.prototype.commitParameters = function (parameters, onlyVisible) {
-        if (parameters === void 0) { parameters = {}; }
-        if (onlyVisible === void 0) { onlyVisible = true; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var instances, promises;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.parameters = lodash_es_1.merge(this.parameters, parameters);
-                        this.allDefinitions.forEach(function (definition) { return (definition.parameters = lodash_es_1.merge(definition.parameters, _this.parameters)); });
-                        instances = this.all;
-                        if (onlyVisible) {
-                            instances = this.all.filter(function (instance) { return instance.variant.visible; });
-                        }
-                        promises = instances.map(function (instance) { return instance.variant.commitParameters(_this.parameters); });
-                        return [4 /*yield*/, Promise.all(promises)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this];
-                }
-            });
-        });
-    };
-    /**
-     * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
-     * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
-     * the calls end up in a queue according to the FIFO principle (the last one wins).
-     */
-    VariantInstanceManager.prototype.show = function (name, exclusive) {
-        if (exclusive === void 0) { exclusive = false; }
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var promise, i, instance;
-            var _this = this;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise = new Promise(function (resolve) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
-                            var instance;
-                            return tslib_1.__generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0:
-                                        if (!exclusive) return [3 /*break*/, 2];
-                                        this.allDefinitions
-                                            .filter(function (definition) { return definition.name !== name; })
-                                            .forEach(function (definition) {
-                                            var parameters = {};
-                                            parameters[parameter_1.Parameter.VISIBLE] = false;
-                                            definition.parameters = lodash_es_1.merge(definition.parameters, parameters);
-                                        });
-                                        return [4 /*yield*/, Promise.all(this.all
-                                                .filter(function (_instance) { return _instance.name !== name; })
-                                                .map(function (_instance) {
-                                                return _instance.variant.hide();
-                                            }))];
-                                    case 1:
-                                        _a.sent();
-                                        _a.label = 2;
-                                    case 2: return [4 /*yield*/, this.get(name)];
-                                    case 3:
-                                        instance = _a.sent();
-                                        return [4 /*yield*/, instance.variant.show()];
-                                    case 4:
-                                        _a.sent();
-                                        resolve(instance);
-                                        return [2 /*return*/];
-                                }
-                            });
-                        }); });
-                        if (!this.queues['show']) {
-                            this.queues['show'] = [];
-                        }
-                        this.queues['show'].push(promise);
-                        i = 0;
-                        _a.label = 1;
-                    case 1:
-                        if (!(i < this.queues['show'].length)) return [3 /*break*/, 5];
-                        return [4 /*yield*/, this.queues['show'][i]];
-                    case 2:
-                        instance = _a.sent();
-                        if (!exclusive) return [3 /*break*/, 4];
-                        if (!(i + 1 < this.queues['show'].length)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, instance.variant.hide()];
-                    case 3:
-                        _a.sent();
-                        _a.label = 4;
-                    case 4:
-                        i++;
-                        return [3 /*break*/, 1];
-                    case 5:
-                        this.queues['show'] = [];
-                        return [2 /*return*/, promise];
-                }
-            });
-        });
-    };
-    /**
-     * Clones and registers a new {@link VariantInstance} with a new, unique name.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
-     */
-    VariantInstanceManager.prototype.clone = function (name, newName, parameters) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var variantInstance, definition, living, variantInstanceClone;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!this.variantInstances.has(name)) {
-                            throw Error("VariantInstance with name \"" + name + "\" does not exist.");
-                        }
-                        variantInstance = this.variantInstances.get(name);
-                        definition = {
-                            name: this.ensureUniqueName(newName ? newName : name),
-                            variant: variantInstance.variant.id,
-                            parameters: parameters,
-                        };
-                        return [4 /*yield*/, variantInstance.variant.createLiving(definition.parameters)];
-                    case 1:
-                        living = _a.sent();
-                        variantInstanceClone = new variantInstance_1.VariantInstance(living, definition.name);
-                        this.variantInstances.set(definition.name, variantInstanceClone);
-                        variantInstance.broadcastEvent(event_1.Event.VARIANT_INSTANCE_CLONED, variantInstanceClone);
-                        return [2 /*return*/, variantInstanceClone];
-                }
-            });
-        });
-    };
-    /**
-     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
-     */
-    VariantInstanceManager.prototype.destroy = function (name) {
-        if (!this.variantInstances.has(name)) {
-            throw Error("VariantInstance with name \"" + name + "\" does not exist.");
-        }
-        var variantInstance = this.variantInstances.get(name);
-        variantInstance.variant.destroy();
-        this.variantInstances.delete(name);
-        variantInstance.broadcastEvent(event_1.Event.VARIANT_INSTANCE_DESTROYED, variantInstance);
-        return this;
-    };
-    /**
-     * Creates and registers a unique {@link VariantInstance} from `definition`.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    VariantInstanceManager.prototype.createFromDefinition = function (definition) {
-        return tslib_1.__awaiter(this, void 0, void 0, function () {
-            var variant, living, variantInstance;
-            return tslib_1.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (!definition.name) {
-                            throw new Error("Given VariantInstanceDefinition " + definition.variant + " is missing a name property.");
-                        }
-                        if (this.variantInstances.has(definition.name)) {
-                            throw new Error("VariantInstance with name \"" + definition.name + "\" is already created.");
-                        }
-                        if (!this.rootVariant) {
-                            throw new Error("Viewer has not been properly bootstrapped (rootVariant missing).");
-                        }
-                        return [4 /*yield*/, this.rootVariant.getDescendant(definition.variant)];
-                    case 1:
-                        variant = _a.sent();
-                        return [4 /*yield*/, variant.createLiving(definition.parameters)];
-                    case 2:
-                        living = _a.sent();
-                        variantInstance = new variantInstance_1.VariantInstance(living, definition.name);
-                        this.variantInstances.set(definition.name, variantInstance);
-                        this.broadcastEvent(event_1.Event.VARIANT_INSTANCE_CREATED, variantInstance);
-                        return [2 /*return*/, variantInstance];
-                }
-            });
-        });
-    };
-    /**
-     * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
-     * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
-     */
-    VariantInstanceManager.prototype.ensureUniqueName = function (name) {
-        var instanceName = name;
-        var i = 1;
-        while (this.has(instanceName)) {
-            instanceName = name + "_" + i;
-            i++;
-        }
-        return instanceName;
-    };
-    return VariantInstanceManager;
-}(eventBroadcaster_1.EventBroadcaster));
-exports.VariantInstanceManager = VariantInstanceManager;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariantInstanceManager = void 0;
+var tslib_1 = require("tslib");
+var lodash_es_1 = require("lodash-es");
+var dottedPath_1 = require("../classes/dottedPath");
+var event_1 = require("../classes/event");
+var eventBroadcaster_1 = require("../classes/eventBroadcaster");
+var parameter_1 = require("../classes/parameter");
+var variantInstance_1 = require("../classes/variantInstance");
+/**
+ * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
+ * {@link Viewer} instance via its {@link Viewer.variantInstances}
+ */
+var VariantInstanceManager = /** @class */ (function (_super) {
+    tslib_1.__extends(VariantInstanceManager, _super);
+    /**
+     * Constructor.
+     */
+    function VariantInstanceManager(rootVariant) {
+        var _this = _super.call(this) || this;
+        _this.rootVariant = rootVariant;
+        _this.variantInstancePromises = new Map();
+        _this.variantInstances = new Map();
+        _this.variantInstanceDefinitions = new Map();
+        _this.parameters = {};
+        _this.queues = {};
+        return _this;
+    }
+    /**
+     * Creates a {@link VariantInstanceManager} based on given root Variant.
+     */
+    VariantInstanceManager.create = function (rootVariant) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                return [2 /*return*/, new VariantInstanceManager(rootVariant)];
+            });
+        });
+    };
+    Object.defineProperty(VariantInstanceManager.prototype, "all", {
+        /**
+         * Gets all instances.
+         */
+        get: function () {
+            var all = [];
+            this.variantInstances.forEach(function (variantInstance) { return all.push(variantInstance); });
+            return all;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(VariantInstanceManager.prototype, "allDefinitions", {
+        /**
+         * Gets all instance definitions.
+         */
+        get: function () {
+            var all = [];
+            this.variantInstanceDefinitions.forEach(function (definition) { return all.push(definition); });
+            return all;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Checks whether a {@link VariantInstance} is either registered or created.
+     */
+    VariantInstanceManager.prototype.has = function (name) {
+        return this.variantInstances.has(name) || this.variantInstanceDefinitions.has(name);
+    };
+    /**
+     * Retrieves a {@link VariantInstance}.
+     * If the instance has been created, the created instance will be returned.
+     * If the instance is registered, the instance will be created and returned.
+     * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
+     * If none of these apply, an Error is thrown.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    VariantInstanceManager.prototype.get = function (name) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var definition, vip;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                // 1) see if we have an instance of that name already and return it if found
+                if (this.variantInstances.has(name)) {
+                    return [2 /*return*/, this.variantInstances.get(name)]; // cannot be null, hence the exclamation mark
+                }
+                // 2) try to get promise from list of requested instances and return it if found
+                if (this.variantInstancePromises.has(name)) {
+                    return [2 /*return*/, this.variantInstancePromises.get(name)];
+                }
+                // 3) see if there's a definition of that name, create an instance from it and store the related promise
+                if (this.variantInstanceDefinitions.has(name)) {
+                    definition = this.variantInstanceDefinitions.get(name);
+                    vip = this.createFromDefinition(definition);
+                    this.variantInstancePromises.set(name, vip);
+                    // remove promise after it has been finished
+                    vip.then(function () { return _this.variantInstancePromises.delete(name); });
+                    return [2 /*return*/, vip];
+                }
+                //* if we are here, no instance definition of that name exists. throw error.
+                throw Error("VariantInstance with name \"" + name + "\" neither created nor configured.");
+            });
+        });
+    };
+    /**
+     * Creates and registers a unique {@link VariantInstance}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    VariantInstanceManager.prototype.create = function (dottedPath, name, parameters) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var variant, definition;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        variant = dottedPath_1.DottedPath.create(dottedPath).path;
+                        definition = {
+                            name: this.ensureUniqueName(name ? name : variant),
+                            variant: variant,
+                            parameters: parameters,
+                        };
+                        return [4 /*yield*/, this.createFromDefinition(definition)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Registers a unique {@link VariantInstanceDefinition}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
+     */
+    VariantInstanceManager.prototype.register = function (instanceDefinition) {
+        var name = instanceDefinition.name ? instanceDefinition.name : dottedPath_1.DottedPath.create(instanceDefinition.variant).path;
+        instanceDefinition.name = this.ensureUniqueName(name);
+        this.variantInstanceDefinitions.set(instanceDefinition.name, instanceDefinition);
+        this.broadcastEvent(event_1.Event.VARIANT_INSTANCE_REGISTERED, instanceDefinition);
+        return instanceDefinition;
+    };
+    /**
+     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
+     */
+    VariantInstanceManager.prototype.commitParameters = function (parameters, onlyVisible) {
+        if (parameters === void 0) { parameters = {}; }
+        if (onlyVisible === void 0) { onlyVisible = true; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var instances, promises;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this.parameters = lodash_es_1.merge(this.parameters, parameters);
+                        this.allDefinitions.forEach(function (definition) { return (definition.parameters = lodash_es_1.merge(definition.parameters, _this.parameters)); });
+                        instances = this.all;
+                        if (onlyVisible) {
+                            instances = this.all.filter(function (instance) { return instance.variant.visible; });
+                        }
+                        promises = instances.map(function (instance) { return instance.variant.commitParameters(_this.parameters); });
+                        return [4 /*yield*/, Promise.all(promises)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, this];
+                }
+            });
+        });
+    };
+    /**
+     * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
+     * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
+     * the calls end up in a queue according to the FIFO principle (the last one wins).
+     */
+    VariantInstanceManager.prototype.show = function (name, exclusive) {
+        if (exclusive === void 0) { exclusive = false; }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var promise, i, instance;
+            var _this = this;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        promise = new Promise(function (resolve) { return tslib_1.__awaiter(_this, void 0, void 0, function () {
+                            var instance;
+                            return tslib_1.__generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0:
+                                        if (!exclusive) return [3 /*break*/, 2];
+                                        this.allDefinitions
+                                            .filter(function (definition) { return definition.name !== name; })
+                                            .forEach(function (definition) {
+                                            var parameters = {};
+                                            parameters[parameter_1.Parameter.VISIBLE] = false;
+                                            definition.parameters = lodash_es_1.merge(definition.parameters, parameters);
+                                        });
+                                        return [4 /*yield*/, Promise.all(this.all
+                                                .filter(function (_instance) { return _instance.name !== name; })
+                                                .map(function (_instance) {
+                                                return _instance.variant.hide();
+                                            }))];
+                                    case 1:
+                                        _a.sent();
+                                        _a.label = 2;
+                                    case 2: return [4 /*yield*/, this.get(name)];
+                                    case 3:
+                                        instance = _a.sent();
+                                        return [4 /*yield*/, instance.variant.show()];
+                                    case 4:
+                                        _a.sent();
+                                        resolve(instance);
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); });
+                        if (!this.queues['show']) {
+                            this.queues['show'] = [];
+                        }
+                        this.queues['show'].push(promise);
+                        i = 0;
+                        _a.label = 1;
+                    case 1:
+                        if (!(i < this.queues['show'].length)) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.queues['show'][i]];
+                    case 2:
+                        instance = _a.sent();
+                        if (!exclusive) return [3 /*break*/, 4];
+                        if (!(i + 1 < this.queues['show'].length)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, instance.variant.hide()];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4:
+                        i++;
+                        return [3 /*break*/, 1];
+                    case 5:
+                        this.queues['show'] = [];
+                        return [2 /*return*/, promise];
+                }
+            });
+        });
+    };
+    /**
+     * Clones and registers a new {@link VariantInstance} with a new, unique name.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
+     */
+    VariantInstanceManager.prototype.clone = function (name, newName, parameters) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var variantInstance, definition, living, variantInstanceClone;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.variantInstances.has(name)) {
+                            throw Error("VariantInstance with name \"" + name + "\" does not exist.");
+                        }
+                        variantInstance = this.variantInstances.get(name);
+                        definition = {
+                            name: this.ensureUniqueName(newName ? newName : name),
+                            variant: variantInstance.variant.id,
+                            parameters: parameters,
+                        };
+                        return [4 /*yield*/, variantInstance.variant.createLiving(definition.parameters)];
+                    case 1:
+                        living = _a.sent();
+                        variantInstanceClone = new variantInstance_1.VariantInstance(living, definition.name);
+                        this.variantInstances.set(definition.name, variantInstanceClone);
+                        variantInstance.broadcastEvent(event_1.Event.VARIANT_INSTANCE_CLONED, variantInstanceClone);
+                        return [2 /*return*/, variantInstanceClone];
+                }
+            });
+        });
+    };
+    /**
+     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
+     */
+    VariantInstanceManager.prototype.destroy = function (name) {
+        if (!this.variantInstances.has(name)) {
+            throw Error("VariantInstance with name \"" + name + "\" does not exist.");
+        }
+        var variantInstance = this.variantInstances.get(name);
+        variantInstance.variant.destroy();
+        this.variantInstances.delete(name);
+        variantInstance.broadcastEvent(event_1.Event.VARIANT_INSTANCE_DESTROYED, variantInstance);
+        return this;
+    };
+    /**
+     * Creates and registers a unique {@link VariantInstance} from `definition`.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    VariantInstanceManager.prototype.createFromDefinition = function (definition) {
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            var variant, living, variantInstance;
+            return tslib_1.__generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!definition.name) {
+                            throw new Error("Given VariantInstanceDefinition " + definition.variant + " is missing a name property.");
+                        }
+                        if (this.variantInstances.has(definition.name)) {
+                            throw new Error("VariantInstance with name \"" + definition.name + "\" is already created.");
+                        }
+                        if (!this.rootVariant) {
+                            throw new Error("Viewer has not been properly bootstrapped (rootVariant missing).");
+                        }
+                        return [4 /*yield*/, this.rootVariant.getDescendant(definition.variant)];
+                    case 1:
+                        variant = _a.sent();
+                        return [4 /*yield*/, variant.createLiving(definition.parameters)];
+                    case 2:
+                        living = _a.sent();
+                        variantInstance = new variantInstance_1.VariantInstance(living, definition.name);
+                        this.variantInstances.set(definition.name, variantInstance);
+                        this.broadcastEvent(event_1.Event.VARIANT_INSTANCE_CREATED, variantInstance);
+                        return [2 /*return*/, variantInstance];
+                }
+            });
+        });
+    };
+    /**
+     * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
+     * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
+     */
+    VariantInstanceManager.prototype.ensureUniqueName = function (name) {
+        var instanceName = name;
+        var i = 1;
+        while (this.has(instanceName)) {
+            instanceName = name + "_" + i;
+            i++;
+        }
+        return instanceName;
+    };
+    return VariantInstanceManager;
+}(eventBroadcaster_1.EventBroadcaster));
+exports.VariantInstanceManager = VariantInstanceManager;
 //# sourceMappingURL=variantInstanceManager.js.map