@combeenation/3d-viewer 5.1.2 → 5.2.0-alpha4

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

@@ -1,333 +1,257 @@
-import { __awaiter, __extends, __generator } from "tslib";
-import { merge } from 'lodash-es';
-import { DottedPath } from '../classes/dottedPath';
-import { Event } from '../classes/event';
-import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { Parameter } from '../classes/parameter';
-import { VariantInstance } from '../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) {
-    __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 __awaiter(this, void 0, void 0, function () {
-            return __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 __awaiter(this, void 0, void 0, function () {
-            var definition, vip;
-            var _this = this;
-            return __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 __awaiter(this, void 0, void 0, function () {
-            var variant, definition;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        variant = 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.create(instanceDefinition.variant).path;
-        instanceDefinition.name = this.ensureUniqueName(name);
-        this.variantInstanceDefinitions.set(instanceDefinition.name, instanceDefinition);
-        this.broadcastEvent(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 __awaiter(this, void 0, void 0, function () {
-            var instances, promises;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.parameters = merge(this.parameters, parameters);
-                        this.allDefinitions.forEach(function (definition) { return (definition.parameters = 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 __awaiter(this, void 0, void 0, function () {
-            var promise, i, instance;
-            var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        promise = new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
-                            var instance;
-                            return __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.VISIBLE] = false;
-                                            definition.parameters = 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 __awaiter(this, void 0, void 0, function () {
-            var variantInstance, definition, living, variantInstanceClone;
-            return __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(living, definition.name);
-                        this.variantInstances.set(definition.name, variantInstanceClone);
-                        variantInstance.broadcastEvent(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.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 __awaiter(this, void 0, void 0, function () {
-            var variant, living, variantInstance;
-            return __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(living, definition.name);
-                        this.variantInstances.set(definition.name, variantInstance);
-                        this.broadcastEvent(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));
-export { VariantInstanceManager };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { DottedPath } from '../classes/dottedPath';
+import { Event } from '../classes/event';
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Parameter } from '../classes/parameter';
+import { VariantInstance } from '../classes/variantInstance';
+import { merge } from 'lodash-es';
+/**
+ * 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}
+ */
+export class VariantInstanceManager extends EventBroadcaster {
+    /**
+     * Constructor.
+     */
+    constructor(rootVariant) {
+        super();
+        this.rootVariant = rootVariant;
+        this.variantInstancePromises = new Map();
+        this.variantInstances = new Map();
+        this.variantInstanceDefinitions = new Map();
+        this.parameters = {};
+        this.queues = {};
+    }
+    /**
+     * Creates a {@link VariantInstanceManager} based on given root Variant.
+     */
+    static create(rootVariant) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new VariantInstanceManager(rootVariant);
+        });
+    }
+    /**
+     * Gets all instances.
+     */
+    get all() {
+        const all = [];
+        this.variantInstances.forEach(variantInstance => all.push(variantInstance));
+        return all;
+    }
+    /**
+     * Gets all instance definitions.
+     */
+    get allDefinitions() {
+        const all = [];
+        this.variantInstanceDefinitions.forEach(definition => all.push(definition));
+        return all;
+    }
+    /**
+     * Checks whether a {@link VariantInstance} is either registered or created.
+     */
+    has(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}
+     */
+    get(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 1) see if we have an instance of that name already and return it if found
+            if (this.variantInstances.has(name)) {
+                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 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)) {
+                const definition = this.variantInstanceDefinitions.get(name); // cannot be null
+                const vip = this.createFromDefinition(definition);
+                this.variantInstancePromises.set(name, vip);
+                // remove promise after it has been finished
+                vip.then(() => this.variantInstancePromises.delete(name));
+                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}
+     */
+    create(dottedPath, name, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const variant = DottedPath.create(dottedPath).path;
+            const definition = {
+                name: this.ensureUniqueName(name ? name : variant),
+                variant: variant,
+                parameters: parameters,
+            };
+            return yield this.createFromDefinition(definition);
+        });
+    }
+    /**
+     * Registers a unique {@link VariantInstanceDefinition}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
+     */
+    register(instanceDefinition) {
+        const name = instanceDefinition.name ? instanceDefinition.name : DottedPath.create(instanceDefinition.variant).path;
+        instanceDefinition.name = this.ensureUniqueName(name);
+        this.variantInstanceDefinitions.set(instanceDefinition.name, instanceDefinition);
+        this.broadcastEvent(Event.VARIANT_INSTANCE_REGISTERED, instanceDefinition);
+        return instanceDefinition;
+    }
+    /**
+     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
+     */
+    commitParameters(parameters = {}, onlyVisible = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.parameters = merge(this.parameters, parameters);
+            this.allDefinitions.forEach(definition => (definition.parameters = merge(definition.parameters, this.parameters)));
+            let instances = this.all;
+            if (onlyVisible) {
+                instances = this.all.filter(instance => instance.variant.visible);
+            }
+            const promises = instances.map(instance => instance.variant.commitParameters(this.parameters));
+            yield Promise.all(promises);
+            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).
+     */
+    show(name, exclusive = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promise = new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                if (exclusive) {
+                    this.allDefinitions
+                        .filter(definition => definition.name !== name)
+                        .forEach(definition => {
+                        const parameters = {};
+                        parameters[Parameter.VISIBLE] = false;
+                        definition.parameters = merge(definition.parameters, parameters);
+                    });
+                    yield Promise.all(this.all
+                        .filter(_instance => _instance.name !== name)
+                        .map(_instance => {
+                        return _instance.variant.hide();
+                    }));
+                }
+                const instance = yield this.get(name);
+                yield instance.variant.show();
+                resolve(instance);
+            }));
+            if (!this.queues['show']) {
+                this.queues['show'] = [];
+            }
+            this.queues['show'].push(promise);
+            for (let i = 0; i < this.queues['show'].length; i++) {
+                const instance = yield this.queues['show'][i];
+                if (exclusive) {
+                    if (i + 1 < this.queues['show'].length) {
+                        yield instance.variant.hide();
+                    }
+                }
+            }
+            this.queues['show'] = [];
+            return promise;
+        });
+    }
+    /**
+     * Clones and registers a new {@link VariantInstance} with a new, unique name.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
+     */
+    clone(name, newName, parameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.variantInstances.has(name)) {
+                throw Error(`VariantInstance with name "${name}" does not exist.`);
+            }
+            const variantInstance = this.variantInstances.get(name);
+            const definition = {
+                name: this.ensureUniqueName(newName ? newName : name),
+                variant: variantInstance.variant.id,
+                parameters: parameters,
+            };
+            const living = yield variantInstance.variant.createLiving(definition.parameters);
+            const variantInstanceClone = new VariantInstance(living, definition.name);
+            this.variantInstances.set(definition.name, variantInstanceClone);
+            variantInstance.broadcastEvent(Event.VARIANT_INSTANCE_CLONED, variantInstanceClone);
+            return variantInstanceClone;
+        });
+    }
+    /**
+     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
+     */
+    destroy(name) {
+        if (!this.variantInstances.has(name)) {
+            throw Error(`VariantInstance with name "${name}" does not exist.`);
+        }
+        const variantInstance = this.variantInstances.get(name);
+        variantInstance.variant.destroy();
+        this.variantInstances.delete(name);
+        variantInstance.broadcastEvent(Event.VARIANT_INSTANCE_DESTROYED, variantInstance);
+        return this;
+    }
+    /**
+     * Creates and registers a unique {@link VariantInstance} from `definition`.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    createFromDefinition(definition) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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).`);
+            }
+            const variant = yield this.rootVariant.getDescendant(definition.variant);
+            const living = yield variant.createLiving(definition.parameters);
+            const variantInstance = new VariantInstance(living, definition.name);
+            this.variantInstances.set(definition.name, variantInstance);
+            this.broadcastEvent(Event.VARIANT_INSTANCE_CREATED, variantInstance);
+            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.
+     */
+    ensureUniqueName(name) {
+        let instanceName = name;
+        let i = 1;
+        while (this.has(instanceName)) {
+            instanceName = `${name}_${i}`;
+            i++;
+        }
+        return instanceName;
+    }
+}
 //# sourceMappingURL=variantInstanceManager.js.map