@combeenation/3d-viewer 6.1.0 → 6.2.0

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

@@ -1,261 +1,261 @@
-"use strict";
-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());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VariantInstanceManager = void 0;
-const dottedPath_1 = require("../classes/dottedPath");
-const event_1 = require("../classes/event");
-const eventBroadcaster_1 = require("../classes/eventBroadcaster");
-const parameter_1 = require("../classes/parameter");
-const variantInstance_1 = require("../classes/variantInstance");
-const lodash_es_1 = require("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}
- */
-class VariantInstanceManager extends eventBroadcaster_1.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_1.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_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.
-     */
-    commitParameters(parameters = {}, onlyVisible = true) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.parameters = (0, lodash_es_1.merge)(this.parameters, parameters);
-            this.allDefinitions.forEach(definition => (definition.parameters = (0, lodash_es_1.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_1.Parameter.VISIBLE] = false;
-                        definition.parameters = (0, lodash_es_1.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_1.VariantInstance(living, definition.name);
-            this.variantInstances.set(definition.name, variantInstanceClone);
-            variantInstance.broadcastEvent(event_1.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_1.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_1.VariantInstance(living, definition.name);
-            this.variantInstances.set(definition.name, variantInstance);
-            this.broadcastEvent(event_1.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;
-    }
-}
-exports.VariantInstanceManager = VariantInstanceManager;
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariantInstanceManager = void 0;
+const dottedPath_1 = require("../classes/dottedPath");
+const event_1 = require("../classes/event");
+const eventBroadcaster_1 = require("../classes/eventBroadcaster");
+const parameter_1 = require("../classes/parameter");
+const variantInstance_1 = require("../classes/variantInstance");
+const lodash_es_1 = require("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}
+ */
+class VariantInstanceManager extends eventBroadcaster_1.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_1.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_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.
+     */
+    commitParameters(parameters = {}, onlyVisible = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.parameters = (0, lodash_es_1.merge)(this.parameters, parameters);
+            this.allDefinitions.forEach(definition => (definition.parameters = (0, lodash_es_1.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_1.Parameter.VISIBLE] = false;
+                        definition.parameters = (0, lodash_es_1.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_1.VariantInstance(living, definition.name);
+            this.variantInstances.set(definition.name, variantInstanceClone);
+            variantInstance.broadcastEvent(event_1.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_1.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_1.VariantInstance(living, definition.name);
+            this.variantInstances.set(definition.name, variantInstance);
+            this.broadcastEvent(event_1.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;
+    }
+}
+exports.VariantInstanceManager = VariantInstanceManager;
 //# sourceMappingURL=variantInstanceManager.js.map

package/dist/lib-cjs/api/store/specStorage.d.ts

@@ -1,24 +1,24 @@
-export declare class SpecStorage {
-    protected spec: StructureJson;
-    static instance: SpecStorage | undefined;
-    /**
-     * Constructor.
-     */
-    protected constructor(spec: StructureJson);
-    /**
-     * Creates {@link SpecStorage} from spec.
-     */
-    static createFromSpec(structureJson: StructureJson): SpecStorage;
-    /**
-     * Destroys the current instance to allow reinstantiating the SpecStorage.
-     */
-    static destroy(): void;
-    /**
-     * Gets spec from key.
-     */
-    static get<T>(key?: string): T;
-    /**
-     * Sets value for spec for given key.
-     */
-    static set<T>(key: string, value: T): typeof SpecStorage;
-}
+export declare class SpecStorage {
+    protected spec: StructureJson;
+    static instance: SpecStorage | undefined;
+    /**
+     * Constructor.
+     */
+    protected constructor(spec: StructureJson);
+    /**
+     * Creates {@link SpecStorage} from spec.
+     */
+    static createFromSpec(structureJson: StructureJson): SpecStorage;
+    /**
+     * Destroys the current instance to allow reinstantiating the SpecStorage.
+     */
+    static destroy(): void;
+    /**
+     * Gets spec from key.
+     */
+    static get<T>(key?: string): T;
+    /**
+     * Sets value for spec for given key.
+     */
+    static set<T>(key: string, value: T): typeof SpecStorage;
+}