@combeenation/3d-viewer 7.1.3 → 8.1.0-alpha1

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

@@ -1,445 +1,509 @@
-"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.TagManager = void 0;
-const event_1 = require("../classes/event");
-const fuzzyMap_1 = require("../classes/fuzzyMap");
-const parameter_1 = require("../classes/parameter");
-const viewer_1 = require("../classes/viewer");
-const babylonHelper_1 = require("../util/babylonHelper");
-const tags_1 = require("@babylonjs/core/Misc/tags");
-const lodash_es_1 = require("lodash-es");
-class TagManager {
-    /**
-     * Constructor.
-     */
-    constructor(viewer) {
-        this.viewer = viewer;
-        this.parameters = new fuzzyMap_1.FuzzyMap();
-        this.parameterObservers = new Map();
-        this.addParameterObservers();
-    }
-    /**
-     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
-     * nodes with given tagName.
-     */
-    setTagParameterValue(tagName, parameterName, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.handleParameter({ tagName: tagName }, parameterName, value);
-        });
-    }
-    /**
-     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
-     * nodes with given nodeName.
-     */
-    setNodeParameterValue(nodeName, parameterName, value) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.handleParameter({ nodeName: nodeName }, parameterName, value);
-        });
-    }
-    /**
-     * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
-     * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
-     * map of passed {@link TagManagerParameterValue}s and the associated {@link ParameterObserverResult} of the
-     * {@link ParameterObserver}.
-     */
-    setParameterValues(values) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const observerResultMap = new Map();
-            const tagPromises = [];
-            const nodePromises = [];
-            for (const value of values) {
-                const subject = {};
-                if (value.tagName) {
-                    subject.tagName = value.tagName;
-                }
-                if (value.nodeName) {
-                    subject.nodeName = value.nodeName;
-                }
-                const observerResultPromise = this.handleParameter(subject, value.parameterName, value.value);
-                observerResultPromise.then(result => observerResultMap.set(value, result));
-                if (value.tagName) {
-                    tagPromises.push(observerResultPromise);
-                }
-                if (value.nodeName) {
-                    nodePromises.push(observerResultPromise);
-                }
-            }
-            yield Promise.all(tagPromises);
-            yield Promise.all(nodePromises);
-            return observerResultMap;
-        });
-    }
-    /**
-     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-     * {@link parameters} and the given node.
-     */
-    getSubjectsFor(node) {
-        return [...this.parameters.keys()].filter(subject => (subject.tagName && tags_1.Tags.MatchesQuery(node, subject.tagName)) ||
-            (subject.nodeName && node.name === subject.nodeName));
-    }
-    /**
-     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
-     * {@link parameters} and the given nodes.
-     */
-    getApplicableSubjectsFor(nodes) {
-        let applicableSubjects = [];
-        for (const node of nodes) {
-            const subjects = this.getSubjectsFor(node);
-            applicableSubjects = [...applicableSubjects, ...subjects];
-        }
-        return (0, lodash_es_1.uniq)(applicableSubjects);
-    }
-    /**
-     * Applies all existing states of the {@link TagManager}'s {@link parameters} for given {@link TagManagerSubject}s.
-     */
-    applyExistingParameterValuesFor(subjects) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const observerResultMap = new Map();
-            let tagPromises = [];
-            let nodePromises = [];
-            for (const subject of subjects) {
-                this.clearAppliedNodeMetadataParameters(this.getNodesBySubject(subject));
-                const observerResultPromises = this.handleParameterBag(subject, this.parameters.get(subject));
-                for (const observerResultPromise of observerResultPromises) {
-                    observerResultPromise.then(result => observerResultMap.set(subject, result));
-                }
-                if (subject.tagName) {
-                    tagPromises = [...tagPromises, ...observerResultPromises];
-                }
-                if (subject.nodeName) {
-                    nodePromises = [...nodePromises, ...observerResultPromises];
-                }
-            }
-            yield Promise.all(tagPromises);
-            yield Promise.all(nodePromises);
-            return observerResultMap;
-        });
-    }
-    /**
-     * Does the same as {@link setParameterValues} with the difference that all existing states of the
-     * {@link TagManager}'s {@link parameters} are applied to all given nodes.
-     */
-    applyExistingParameterValuesTo(nodes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.applyExistingParameterValuesFor(this.getApplicableSubjectsFor(nodes));
-        });
-    }
-    /**
-     * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
-     */
-    applyExistingParameterValues() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.applyExistingParameterValuesFor([...this.parameters.keys()]);
-        });
-    }
-    /**
-     * Maps all tags on given nodes with the {@link TagMapping} and updates the state of the {@link TagManager}'s
-     * {@link parameters} for all new tags.
-     * Also updates the state of all nodes in the tag managers parameter state.
-     */
-    mapNodesAndTags(nodes, tagMapping) {
-        this.updateParametersWithNodeAndTagMapping(nodes, tagMapping);
-        (0, babylonHelper_1.mapTags)(nodes, tagMapping);
-        return this;
-    }
-    /**
-     * Gets a distinct list of all tags within the current scene.
-     */
-    getAllTags() {
-        var _a;
-        const tags = [];
-        const nodes = this.viewer.scene.getNodes();
-        for (const node of nodes) {
-            tags.push(...Object.keys((_a = tags_1.Tags.GetTags(node, false)) !== null && _a !== void 0 ? _a : {}));
-        }
-        return [...new Set(tags)];
-    }
-    /**
-     * Prints the state of the {@link TagManager}'s {@link parameters} to the console.
-     */
-    printAllTags() {
-        const printable = [];
-        for (const subject of this.parameters.keys()) {
-            const parameterBag = this.parameters.get(subject);
-            for (const parameter in parameterBag) {
-                printable.push({
-                    subject: JSON.stringify(subject),
-                    parameter: parameter,
-                    value: parameterBag[parameter],
-                    nodes: this.getNodesBySubject(subject),
-                });
-            }
-        }
-        console.table(printable);
-    }
-    /**
-     * Prints the state of the {@link TagManager}'s {@link parameters} for one tagName to the console.
-     */
-    printTagInfo(tagName) {
-        const parameterBag = this.parameters.get({ tagName: tagName });
-        const printable = [];
-        for (const parameter in parameterBag) {
-            printable.push({
-                parameter: parameter,
-                value: parameterBag[parameter],
-                nodes: this.getNodesBySubject({ tagName: tagName }),
-            });
-        }
-        console.table(printable);
-    }
-    /**
-     * Sets a {@link ParameterObserver} for the given {@link Parameter}.
-     *
-     * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
-     * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
-     */
-    setParameterObserver(parameter, observer) {
-        this.parameterObservers.set(parameter, observer);
-        return this;
-    }
-    /**
-     * Gets all nodes for given {@link TagManagerSubject} on the Babylon.js scene.
-     */
-    getNodesBySubject(subject, predicate) {
-        let nodes = [];
-        if (subject.tagName) {
-            nodes = [
-                ...nodes,
-                ...this.viewer.scene.getTransformNodesByTags(subject.tagName, predicate),
-                ...this.viewer.scene.getMeshesByTags(subject.tagName, predicate),
-            ];
-        }
-        if (subject.nodeName) {
-            nodes = [
-                ...nodes,
-                this.viewer.scene.getTransformNodeByName(subject.nodeName),
-                this.viewer.scene.getMeshByName(subject.nodeName),
-            ].filter(t => !!t && (!predicate || predicate(t)));
-        }
-        return nodes;
-    }
-    /**
-     * Registers observers that are called on every new node added to the Babylon.js scene. The observers ensure that each
-     * new node gets the state of the {@link TagManager}'s {@link parameters} applied.
-     */
-    registerNewTransformNodeObservers(scene) {
-        const onNewTransformNodeAdded = (node) => {
-            if (node.name === viewer_1.Viewer.BOUNDING_BOX_NAME || !this.viewer.variantInstances.areAllDefinitionsCreated) {
-                // Avoid duplicate calls here. The parameter values are already applied when a variant instance has finished
-                // creating (see event listener in viewer for VARIANT_INSTANCE_CREATED). This callback should only trigger when
-                // a consumer "manually" clones a node.
-                return;
-            }
-            this.applyExistingParameterValuesTo([node]).then();
-        };
-        scene.onNewTransformNodeAddedObservable.makeObserverBottomPriority(scene.onNewTransformNodeAddedObservable.add(onNewTransformNodeAdded));
-        scene.onNewMeshAddedObservable.makeObserverBottomPriority(scene.onNewMeshAddedObservable.add(onNewTransformNodeAdded));
-    }
-    /**
-     * Adds the default {@link ParameterObserver}s.
-     * @protected
-     */
-    addParameterObservers() {
-        this.parameterObservers.set(parameter_1.Parameter.VISIBLE, (payload) => __awaiter(this, void 0, void 0, function* () {
-            let visible;
-            try {
-                visible = parameter_1.Parameter.parseBoolean(payload.newValue);
-            }
-            catch (e) {
-                return false;
-            }
-            if (visible === true) {
-                for (const node of payload.nodes) {
-                    node.setEnabled(true);
-                }
-            }
-            else if (visible === false) {
-                for (const node of payload.nodes) {
-                    node.setEnabled(false);
-                }
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.SCALING, (payload) => __awaiter(this, void 0, void 0, function* () {
-            for (const node of payload.nodes) {
-                node.scaling = parameter_1.Parameter.parseVector(payload.newValue);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.POSITION, (payload) => __awaiter(this, void 0, void 0, function* () {
-            for (const node of payload.nodes) {
-                node.position = parameter_1.Parameter.parseVector(payload.newValue);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.ROTATION, (payload) => __awaiter(this, void 0, void 0, function* () {
-            for (const node of payload.nodes) {
-                node.rotation = parameter_1.Parameter.parseRotation(payload.newValue);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.MATERIAL, (payload) => __awaiter(this, void 0, void 0, function* () {
-            for (const node of payload.nodes) {
-                (0, babylonHelper_1.assertMeshCapability)(node, parameter_1.Parameter.MATERIAL);
-                (0, babylonHelper_1.setMaterial)(node, payload.newValue.toString(), false);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.MATERIAL_COLOR, (payload) => __awaiter(this, void 0, void 0, function* () {
-            const parsedValue = parameter_1.Parameter.parseColor(payload.newValue);
-            for (const node of payload.nodes) {
-                (0, babylonHelper_1.assertMeshCapability)(node, parameter_1.Parameter.MATERIAL_COLOR);
-                if (this.viewer.cloneMaterialsOnMutation) {
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material')) {
-                        (0, babylonHelper_1.cloneTransformNodeMaterial)(node);
-                    }
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material.color')) {
-                        // inject initial value and mark as dirty
-                        (0, babylonHelper_1.injectNodeMetadata)(node, { dirty: { material: { color: payload.oldValue } } }, false);
-                    }
-                }
-                (0, babylonHelper_1.setMaterialColor)(node, parsedValue, false);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.MATERIAL_ROUGHNESS, (payload) => __awaiter(this, void 0, void 0, function* () {
-            const parsedValue = parameter_1.Parameter.parseNumber(payload.newValue);
-            for (const node of payload.nodes) {
-                (0, babylonHelper_1.assertMeshCapability)(node, parameter_1.Parameter.MATERIAL_ROUGHNESS);
-                if (this.viewer.cloneMaterialsOnMutation) {
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material')) {
-                        (0, babylonHelper_1.cloneTransformNodeMaterial)(node);
-                    }
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material.roughness')) {
-                        // inject initial value and mark as dirty
-                        (0, babylonHelper_1.injectNodeMetadata)(node, { dirty: { material: { color: payload.oldValue } } }, false);
-                    }
-                }
-                (0, babylonHelper_1.setMaterialRoughness)(node, parsedValue, false);
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.MATERIAL_METALLNESS, (payload) => __awaiter(this, void 0, void 0, function* () {
-            const parsedValue = parameter_1.Parameter.parseNumber(payload.newValue);
-            for (const node of payload.nodes) {
-                (0, babylonHelper_1.assertMeshCapability)(node, parameter_1.Parameter.MATERIAL_METALLNESS);
-                if (this.viewer.cloneMaterialsOnMutation) {
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material')) {
-                        (0, babylonHelper_1.cloneTransformNodeMaterial)(node);
-                    }
-                    if (!(0, lodash_es_1.has)(node.metadata, 'dirty.material.metallness')) {
-                        // inject initial value and mark as dirty
-                        (0, babylonHelper_1.injectNodeMetadata)(node, { dirty: { material: { color: payload.oldValue } } }, false);
-                    }
-                }
-                (0, babylonHelper_1.setMaterialMetallness)(node, parsedValue, false);
-            }
-            return true;
-        }));
-        return this;
-    }
-    /**
-     * Passes all {@link ParameterValue}s of the given {@link ParameterBag} for given {@link TagManagerSubject} to
-     * {@link handleParameter}.
-     * @protected
-     */
-    handleParameterBag(subject, parameters) {
-        const observerPromises = [];
-        for (const parameter in parameters) {
-            observerPromises.push(this.handleParameter(subject, parameter, parameters[parameter]));
-        }
-        return observerPromises;
-    }
-    /**
-     * Asserts the given {@link Parameter} and its {@link ParameterValue}, stores the state in the {@link TagManager}'s
-     * {@link parameters}, calculates the applicable nodes, injects the {@link ParameterValue} in the node's metadata,
-     * calls the responsible {@link ParameterObserver}s and emits the event {@link Event.TAG_MANAGER_PARAMETER_COMMITTED}.
-     * @protected
-     */
-    handleParameter(subject, parameter, parameterValue) {
-        return __awaiter(this, void 0, void 0, function* () {
-            parameter_1.Parameter.assertParameter(parameter_1.Parameter.declarations, parameter, parameterValue);
-            if (!this.parameterObservers.has(parameter)) {
-                return Promise.resolve(false);
-            }
-            const parameterBag = this.parameters.get(subject) || {};
-            const oldValue = parameterBag[parameter];
-            if (oldValue === parameterValue) {
-                return Promise.resolve(false);
-            }
-            this.parameters.set(subject, parameterBag);
-            this.parameters.get(subject)[parameter] = parameterValue;
-            const nodes = this.getNodesBySubject(subject);
-            if (nodes.length === 0) {
-                return Promise.resolve(false);
-            }
-            const observer = this.parameterObservers.get(parameter);
-            const result = yield observer({ subject: subject, nodes: nodes, newValue: parameterValue, oldValue: oldValue });
-            if (result === false) {
-                // reset to old value if observer was not successful
-                this.parameters.get(subject)[parameter] = oldValue;
-            }
-            event_1.emitter.emit(event_1.Event.TAG_MANAGER_PARAMETER_COMMITTED, {
-                subject: subject,
-                parameter: parameter,
-                nodes: nodes,
-                oldValue: oldValue,
-                newValue: parameterValue,
-                result: result,
-            });
-        });
-    }
-    /**
-     * Updates the state of the {@link TagManager}'s {@link parameters} for all new nodes and tags given in
-     * {@link TagMapping}.
-     * @protected
-     */
-    updateParametersWithNodeAndTagMapping(nodes, tagMapping) {
-        // create node mapping by linking the clone source name to the new node name
-        const nodeMapping = nodes.reduce((accNodeMapping, curNode) => {
-            const oldNode = (0, lodash_es_1.get)(curNode.metadata, 'cloneSource');
-            if (oldNode) {
-                accNodeMapping[oldNode.name] = curNode.name;
-            }
-            return accNodeMapping;
-        }, {});
-        for (const subject of this.parameters.keys()) {
-            const isNode = subject.nodeName;
-            const newName = isNode ? nodeMapping[subject.nodeName] : tagMapping[subject.tagName];
-            if (!newName) {
-                continue;
-            }
-            const newSubject = (0, lodash_es_1.clone)(subject);
-            newSubject[isNode ? 'nodeName' : 'tagName'] = newName;
-            const parameterBag = (0, lodash_es_1.clone)(this.parameters.get(subject));
-            (0, lodash_es_1.merge)(parameterBag, this.parameters.get(newSubject));
-            this.parameters.set(newSubject, parameterBag);
-        }
-    }
-    /**
-     * Clears the applied {@link ParameterBag} state of the node's metadata to ensure that observers trigger (once again).
-     * This is necessary e.g. after mapping tags when a nodeName subject shall override the parameterValue of a mapped
-     * tag.
-     * @protected
-     */
-    clearAppliedNodeMetadataParameters(nodes) {
-        var _a, _b;
-        for (const node of nodes) {
-            if (!((_b = (_a = node.metadata) === null || _a === void 0 ? void 0 : _a.tagManager) === null || _b === void 0 ? void 0 : _b.parameters)) {
-                continue;
-            }
-            node.metadata.tagManager.parameters = {};
-        }
-    }
-}
-exports.TagManager = TagManager;
+"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.TagManager = void 0;
+const event_1 = require("../classes/event");
+const fuzzyMap_1 = require("../classes/fuzzyMap");
+const parameter_1 = require("../classes/parameter");
+const viewer_1 = require("../classes/viewer");
+const babylonHelper_1 = require("../util/babylonHelper");
+const tags_1 = require("@babylonjs/core/Misc/tags");
+const lodash_es_1 = require("lodash-es");
+class TagManager {
+    /**
+     * Constructor.
+     */
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.parameters = new fuzzyMap_1.FuzzyMap();
+        this.parameterObservers = new Map();
+        this.addParameterObservers();
+    }
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given tagName.
+     */
+    setTagParameterValue(tagName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.handleParameter({ tagName: tagName }, parameterName, value);
+        });
+    }
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * nodes with given nodeName.
+     */
+    setNodeParameterValue(nodeName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.handleParameter({ nodeName: nodeName }, parameterName, value);
+        });
+    }
+    /**
+     * Calls the {@link ParameterObserver} for given {@link Parameter} and applies the {@link ParameterValue} on all
+     * materials with given materialName.
+     */
+    setMaterialParameterValue(materialName, parameterName, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.handleParameter({ materialName: materialName }, parameterName, value);
+        });
+    }
+    /**
+     * Splits the passed {@link TagManagerParameterValue}s into individual values and calls all {@link ParameterObserver}s
+     * of all {@link Parameter}s with the respective {@link TagManagerSubject} and {@link ParameterValue}. The result is a
+     * map of passed {@link TagManagerParameterValue}s and the associated {@link TagManagerParameterObserverResult} of the
+     * {@link ParameterObserver}.
+     */
+    setParameterValues(values) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const observerResultMap = new Map();
+            const tagPromises = [];
+            const nodePromises = [];
+            const materialPromises = [];
+            for (const value of values) {
+                const subject = {};
+                if (value.tagName) {
+                    subject.tagName = value.tagName;
+                }
+                if (value.nodeName) {
+                    subject.nodeName = value.nodeName;
+                }
+                if (value.materialName) {
+                    subject.materialName = value.materialName;
+                }
+                const observerResultPromise = this.handleParameter(subject, value.parameterName, value.value);
+                observerResultPromise.then(result => observerResultMap.set(value, result));
+                if (value.tagName) {
+                    tagPromises.push(observerResultPromise);
+                }
+                if (value.nodeName) {
+                    nodePromises.push(observerResultPromise);
+                }
+                if (value.materialName) {
+                    materialPromises.push(observerResultPromise);
+                }
+            }
+            yield Promise.all(tagPromises);
+            yield Promise.all(nodePromises);
+            yield Promise.all(materialPromises);
+            return observerResultMap;
+        });
+    }
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given object.
+     */
+    getSubjectsFor(object) {
+        return [...this.parameters.keys()].filter(subject => (subject.tagName && tags_1.Tags.MatchesQuery(object, subject.tagName)) ||
+            (subject.nodeName && object.name === subject.nodeName) ||
+            (subject.materialName && object.name === subject.materialName));
+    }
+    /**
+     * Gets a list of {@link TagManagerSubject}s that are present in both the state of the {@link TagManager}'s
+     * {@link parameters} and the given objects.
+     */
+    getApplicableSubjectsFor(objects) {
+        let applicableSubjects = [];
+        for (const object of objects) {
+            const subjects = this.getSubjectsFor(object);
+            applicableSubjects = [...applicableSubjects, ...subjects];
+        }
+        return (0, lodash_es_1.uniq)(applicableSubjects);
+    }
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for given {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValuesFor(subjects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const observerResultMap = new Map();
+            let tagPromises = [];
+            let nodePromises = [];
+            let materialPromises = [];
+            for (const subject of subjects) {
+                const observerResultPromises = this.handleParameterBag(subject, this.parameters.get(subject));
+                for (const observerResultPromise of observerResultPromises) {
+                    observerResultPromise.then(result => observerResultMap.set(subject, result));
+                }
+                if (subject.tagName) {
+                    tagPromises = [...tagPromises, ...observerResultPromises];
+                }
+                if (subject.nodeName) {
+                    nodePromises = [...nodePromises, ...observerResultPromises];
+                }
+                if (subject.materialName) {
+                    materialPromises = [...materialPromises, ...observerResultPromises];
+                }
+            }
+            yield Promise.all(tagPromises);
+            yield Promise.all(nodePromises);
+            yield Promise.all(materialPromises);
+            return observerResultMap;
+        });
+    }
+    /**
+     * Does the same as {@link setParameterValues} with the difference that all existing states of the
+     * {@link TagManager}'s {@link parameters} are applied to all given nodes.
+     */
+    applyExistingParameterValuesTo(objects) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.applyExistingParameterValuesFor(this.getApplicableSubjectsFor(objects));
+        });
+    }
+    /**
+     * Applies all existing states of the {@link TagManager}'s {@link parameters} for all {@link TagManagerSubject}s.
+     */
+    applyExistingParameterValues() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.applyExistingParameterValuesFor([...this.parameters.keys()]);
+        });
+    }
+    /**
+     * Maps all tags on given nodes with the {@link TagMapping} and updates the state of the {@link TagManager}'s
+     * {@link parameters} for all new tags.
+     * Also updates the state of all nodes in the tag managers parameter state.
+     */
+    mapNodesAndTags(nodes, tagMapping) {
+        this.updateParametersWithNodeAndTagMapping(nodes, tagMapping);
+        (0, babylonHelper_1.mapTags)(nodes, tagMapping);
+        return this;
+    }
+    /**
+     * Gets a distinct list of all tags within the current scene.
+     */
+    getAllTags() {
+        var _a;
+        const tags = [];
+        const nodes = this.viewer.scene.getNodes();
+        for (const node of nodes) {
+            tags.push(...Object.keys((_a = tags_1.Tags.GetTags(node, false)) !== null && _a !== void 0 ? _a : {}));
+        }
+        return [...new Set(tags)];
+    }
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} to the console.
+     */
+    printAllTags() {
+        const printable = [];
+        for (const subject of this.parameters.keys()) {
+            const parameterBag = this.parameters.get(subject);
+            for (const parameter in parameterBag) {
+                printable.push({
+                    subject: JSON.stringify(subject),
+                    parameter: parameter,
+                    value: parameterBag[parameter],
+                    nodes: this.getNodesBySubject(subject),
+                });
+            }
+        }
+        console.table(printable);
+    }
+    /**
+     * Prints the state of the {@link TagManager}'s {@link parameters} for one tagName to the console.
+     */
+    printTagInfo(tagName) {
+        const parameterBag = this.parameters.get({ tagName: tagName });
+        const printable = [];
+        for (const parameter in parameterBag) {
+            printable.push({
+                parameter: parameter,
+                value: parameterBag[parameter],
+                nodes: this.getNodesBySubject({ tagName: tagName }),
+            });
+        }
+        console.table(printable);
+    }
+    /**
+     * Sets a {@link ParameterObserver} for the given {@link Parameter}.
+     *
+     * The observer should return `false` in cases where the given value was not actually applied. E.g. when wanting to
+     * apply a property on the given `node`s material which doesn't exist at the time the observer is called etc.
+     */
+    setParameterObserver(parameter, observer) {
+        this.parameterObservers.set(parameter, observer);
+        return this;
+    }
+    /**
+     * Gets all nodes for given {@link TagManagerSubject} on the Babylon.js scene.
+     */
+    getNodesBySubject(subject, predicate) {
+        let nodes = [];
+        if (subject.tagName) {
+            nodes = [
+                ...nodes,
+                ...this.viewer.scene.getTransformNodesByTags(subject.tagName, predicate),
+                ...this.viewer.scene.getMeshesByTags(subject.tagName, predicate),
+            ];
+        }
+        if (subject.nodeName) {
+            nodes = [
+                ...nodes,
+                this.viewer.scene.getTransformNodeByName(subject.nodeName),
+                this.viewer.scene.getMeshByName(subject.nodeName),
+            ].filter(t => !!t && (!predicate || predicate(t)));
+        }
+        return nodes;
+    }
+    /**
+     * Gets all materials for given {@link TagManagerSubject} on the Babylon.js scene.
+     */
+    getMaterialsBySubject(subject, predicate) {
+        let materials = [];
+        if (subject.tagName) {
+            materials = [...materials, ...this.viewer.scene.getMaterialByTags(subject.tagName, predicate)];
+        }
+        if (subject.materialName) {
+            materials = [...materials, this.viewer.scene.getMaterialByName(subject.materialName)].filter(t => !!t && (!predicate || predicate(t)));
+        }
+        return materials;
+    }
+    /**
+     * Registers observers that are called on every new object added to the Babylon.js scene.
+     * The observers ensure that each new object gets the state of the {@link TagManager}'s {@link parameters} applied.
+     */
+    registerNewObjectObservers(scene) {
+        // nodes and meshes
+        const onNewTransformNodeAdded = (node) => {
+            /* NOTE:
+               Removed the check for created instances here since it is not guaranteed that all instances
+               created means that there is no scenario where new nodes should get TagManager parameters applied.
+               Instead, we check for the state to be enabled via the `onEnabledStateChangedObservable` below.
+             */
+            //if (node.name === Viewer.BOUNDING_BOX_NAME || !this.viewer.variantInstances.areAllDefinitionsCreated) {
+            if (node.name === viewer_1.Viewer.BOUNDING_BOX_NAME) {
+                return;
+            }
+            const onEnabledStateChangedObserver = node.onEnabledStateChangedObservable.add((state) => __awaiter(this, void 0, void 0, function* () {
+                if (!state) {
+                    // if the node is disabled, means ignoring also "ghost nodes"
+                    return;
+                }
+                yield this.applyExistingParameterValuesTo([node]);
+                node.onEnabledStateChangedObservable.remove(onEnabledStateChangedObserver);
+            }));
+            node.onEnabledStateChangedObservable.makeObserverBottomPriority(onEnabledStateChangedObserver);
+        };
+        scene.onNewTransformNodeAddedObservable.makeObserverBottomPriority(scene.onNewTransformNodeAddedObservable.add(onNewTransformNodeAdded));
+        scene.onNewMeshAddedObservable.makeObserverBottomPriority(scene.onNewMeshAddedObservable.add(onNewTransformNodeAdded));
+        // materials
+        const onNewMaterialAdded = (material) => {
+            /* NOTE:
+                       We have to wait until a material is bound to a Mesh. In all other scenarios, the material
+                       is not "fully ready" or even empty (without working attributes/properties).
+                   */
+            const onMaterialBindObserver = material.onBindObservable.add((abstractMesh) => __awaiter(this, void 0, void 0, function* () {
+                yield this.applyExistingParameterValuesTo([material]);
+                material.onBindObservable.remove(onMaterialBindObserver);
+            }));
+            material.onBindObservable.makeObserverBottomPriority(onMaterialBindObserver);
+        };
+        scene.onNewMaterialAddedObservable.makeObserverBottomPriority(scene.onNewMaterialAddedObservable.add(onNewMaterialAdded));
+    }
+    /**
+     * Adds the default {@link ParameterObserver}s.
+     * @protected
+     */
+    addParameterObservers() {
+        this.parameterObservers.set(parameter_1.Parameter.VISIBLE, (payload) => __awaiter(this, void 0, void 0, function* () {
+            let visible;
+            try {
+                visible = parameter_1.Parameter.parseBoolean(payload.newValue);
+            }
+            catch (e) {
+                return false;
+            }
+            if (visible === true) {
+                for (const node of payload.nodes) {
+                    node.setEnabled(true);
+                }
+            }
+            else if (visible === false) {
+                for (const node of payload.nodes) {
+                    node.setEnabled(false);
+                }
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.SCALING, (payload) => __awaiter(this, void 0, void 0, function* () {
+            for (const node of payload.nodes) {
+                node.scaling = parameter_1.Parameter.parseVector(payload.newValue);
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.POSITION, (payload) => __awaiter(this, void 0, void 0, function* () {
+            for (const node of payload.nodes) {
+                node.position = parameter_1.Parameter.parseVector(payload.newValue);
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.ROTATION, (payload) => __awaiter(this, void 0, void 0, function* () {
+            for (const node of payload.nodes) {
+                node.rotation = parameter_1.Parameter.parseRotation(payload.newValue);
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.MATERIAL, (payload) => __awaiter(this, void 0, void 0, function* () {
+            for (const node of payload.nodes) {
+                (0, babylonHelper_1.assertMeshCapability)(node, parameter_1.Parameter.MATERIAL);
+                (0, babylonHelper_1.setMaterial)(node, payload.newValue.toString(), false);
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.COLOR, (payload) => __awaiter(this, void 0, void 0, function* () {
+            const color = parameter_1.Parameter.parseColor(payload.newValue);
+            for (const material of payload.materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.albedoColor = color.toLinearSpace();
+                        break;
+                    case 'StandardMaterial':
+                        material.diffuseColor = color;
+                        break;
+                    default:
+                        throw new Error(`Setting color for material of instance "${materialCls}" not implemented (yet).`);
+                }
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.ROUGHNESS, (payload) => __awaiter(this, void 0, void 0, function* () {
+            const roughness = parameter_1.Parameter.parseNumber(payload.newValue);
+            for (const material of payload.materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.roughness = roughness;
+                        break;
+                    case 'StandardMaterial':
+                        material.roughness = roughness;
+                        break;
+                    default:
+                        throw new Error(`Setting roughness for material of instance "${materialCls}" not implemented (yet).`);
+                }
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.METALLNESS, (payload) => __awaiter(this, void 0, void 0, function* () {
+            const metallness = parameter_1.Parameter.parseNumber(payload.newValue);
+            for (const material of payload.materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.metallic = metallness;
+                        break;
+                    default:
+                        throw new Error(`Setting metallness for material of instance "${materialCls}" not implemented (yet).`);
+                }
+            }
+            return true;
+        }));
+        return this;
+    }
+    /**
+     * Passes all {@link ParameterValue}s of the given {@link ParameterBag} for given {@link TagManagerSubject} to
+     * {@link handleParameter}.
+     * @protected
+     */
+    handleParameterBag(subject, parameters) {
+        const observerPromises = [];
+        for (const parameter in parameters) {
+            observerPromises.push(this.handleParameter(subject, parameter, parameters[parameter]));
+        }
+        return observerPromises;
+    }
+    /**
+     * Asserts the given {@link Parameter} and its {@link ParameterValue}, stores the state in the {@link TagManager}'s
+     * {@link parameters}, calculates the applicable nodes, injects the {@link ParameterValue} in the node's metadata,
+     * calls the responsible {@link ParameterObserver}s and emits the event {@link Event.TAG_MANAGER_PARAMETER_COMMITTED}.
+     * @protected
+     */
+    handleParameter(subject, parameter, parameterValue) {
+        return __awaiter(this, void 0, void 0, function* () {
+            parameter_1.Parameter.assertParameter(parameter_1.Parameter.declarations, parameter, parameterValue);
+            const parameterBag = this.parameters.get(subject) || {};
+            const oldValue = parameterBag[parameter];
+            const parameterObserverResultBag = {
+                subject: subject,
+                parameter: parameter,
+                nodes: [],
+                materials: [],
+                oldValue: oldValue,
+                newValue: parameterValue,
+                parameterObserverResult: false,
+            };
+            if (!this.parameterObservers.has(parameter)) {
+                return Promise.resolve(parameterObserverResultBag);
+            }
+            if (oldValue === parameterValue) {
+                /* NOTE:
+                   The following is wrong in different scenarios. If a node enters life and the subject/parameter
+                   applied in the past, the new node will not be altered by the subsequent observers, because of
+                   the return on the next line. If we want to tackle that problem and do an early return to not
+                   trigger observers twice, we have to hold a state for every node/material and the applied
+                   parameter value. This could be highly cost sensitive, so I would just avoid that check
+                   at all. Babylon will not trigger changes if the value on a node/material does not change
+                   anyway.
+                 */
+                //return Promise.resolve(parameterObserverResultBag);
+            }
+            this.parameters.set(subject, parameterBag);
+            this.parameters.get(subject)[parameter] = parameterValue;
+            const nodes = this.getNodesBySubject(subject);
+            const materials = this.getMaterialsBySubject(subject);
+            if (nodes.length === 0 && materials.length === 0) {
+                return Promise.resolve(parameterObserverResultBag);
+            }
+            const observer = this.parameterObservers.get(parameter);
+            const result = yield observer({
+                subject: subject,
+                nodes: nodes,
+                materials: materials,
+                newValue: parameterValue,
+                oldValue: oldValue,
+            });
+            if (result === false) {
+                // reset to old value if observer was not successful
+                this.parameters.get(subject)[parameter] = oldValue;
+            }
+            parameterObserverResultBag.nodes = nodes;
+            parameterObserverResultBag.materials = materials;
+            parameterObserverResultBag.parameterObserverResult = result;
+            event_1.emitter.emit(event_1.Event.TAG_MANAGER_PARAMETER_COMMITTED, parameterObserverResultBag);
+            return parameterObserverResultBag;
+        });
+    }
+    /**
+     * Updates the state of the {@link TagManager}'s {@link parameters} for all new nodes and tags given in
+     * {@link TagMapping}.
+     * @protected
+     */
+    updateParametersWithNodeAndTagMapping(nodes, tagMapping) {
+        // create node mapping by linking the clone source name to the new node name
+        const nodeMapping = nodes.reduce((accNodeMapping, curNode) => {
+            const oldNode = (0, lodash_es_1.get)(curNode.metadata, 'cloneSource');
+            if (oldNode) {
+                accNodeMapping[oldNode.name] = curNode.name;
+            }
+            return accNodeMapping;
+        }, {});
+        for (const subject of this.parameters.keys()) {
+            const isNode = subject.nodeName;
+            const newName = isNode ? nodeMapping[subject.nodeName] : tagMapping[subject.tagName];
+            if (!newName) {
+                continue;
+            }
+            const newSubject = (0, lodash_es_1.clone)(subject);
+            newSubject[isNode ? 'nodeName' : 'tagName'] = newName;
+            const parameterBag = (0, lodash_es_1.clone)(this.parameters.get(subject));
+            (0, lodash_es_1.merge)(parameterBag, this.parameters.get(newSubject));
+            this.parameters.set(newSubject, parameterBag);
+        }
+    }
+}
+exports.TagManager = TagManager;
 //# sourceMappingURL=tagManager.js.map