@combeenation/3d-viewer 12.4.1 → 12.4.3

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

@@ -1,531 +1,531 @@
-"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());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-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 viewerError_1 = require("../classes/viewerError");
-const babylonHelper_1 = require("../util/babylonHelper");
-const resourceHelper_1 = require("../util/resourceHelper");
-const tags_1 = require("@babylonjs/core/Misc/tags");
-const is_svg_1 = __importDefault(require("is-svg"));
-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.
-             */
-            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* () {
-            const visible = parameter_1.Parameter.parseBoolean(payload.newValue);
-            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.METALLIC, (payload) => __awaiter(this, void 0, void 0, function* () {
-            const metallic = parameter_1.Parameter.parseNumber(payload.newValue);
-            for (const material of payload.materials) {
-                const materialCls = material.getClassName();
-                switch (materialCls) {
-                    case 'PBRMaterial':
-                        material.metallic = metallic;
-                        break;
-                    default:
-                        throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented (yet).`);
-                }
-            }
-            return true;
-        }));
-        this.parameterObservers.set(parameter_1.Parameter.PAINTABLE, (payload) => __awaiter(this, void 0, void 0, function* () {
-            const paintableValue = parameter_1.Parameter.parsePaintable(payload.newValue);
-            // check if value is svg or image source, do the conversion accordingly
-            const srcIsSvg = (0, is_svg_1.default)(paintableValue.src);
-            if (!srcIsSvg && paintableValue.src.includes('<svg') && paintableValue.src.includes('</svg>')) {
-                // seems like the user tried to use a SVG string, as <svg> tags are used
-                // inform the user that this is not a valid SVG string
-                throw new Error(`Setting paintable value failed: "${paintableValue.src}" is no valid SVG string.`);
-            }
-            let imageSource;
-            try {
-                imageSource = srcIsSvg
-                    ? yield (0, resourceHelper_1.createImageFromSvg)(paintableValue.src)
-                    : yield (0, resourceHelper_1.createImageFromImgSrc)(paintableValue.src);
-            }
-            catch (_a) {
-                // SVG might be invalid, even if it passes `isSvg` check
-                // in this case the image can't be created and will throw an error, which should be handled by the viewer and
-                // Combeenation viewer control
-                throw new viewerError_1.ViewerError({
-                    id: viewerError_1.ViewerErrorIds.InvalidParameterValue,
-                    message: `Invalid value for parameter "paintable" given:\nImage can't be created from source string.\nGiven value: ${paintableValue.src}`,
-                });
-            }
-            // apply image source on desired material(s)
-            for (const material of payload.materials) {
-                (0, babylonHelper_1.drawPaintableOnMaterial)(material, imageSource, this.viewer.scene, paintableValue.options);
-            }
-            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);
-            }
-            this.parameters.set(subject, parameterBag);
-            this.parameters.get(subject)[parameter] = parameterValue;
-            // get objects by subject and filter nodes by state
-            const nodes = this.getNodesBySubject(subject).filter(o => { var _a, _b, _c; return ((_c = (_b = (_a = o.metadata) === null || _a === void 0 ? void 0 : _a.tagManager) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c[parameter]) !== parameterValue; });
-            const materials = this.getMaterialsBySubject(subject).filter(o => { var _a, _b, _c; return ((_c = (_b = (_a = o.metadata) === null || _a === void 0 ? void 0 : _a.tagManager) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c[parameter]) !== parameterValue; });
-            if (nodes.length === 0 && materials.length === 0) {
-                return Promise.resolve(parameterObserverResultBag);
-            }
-            // store state in objects
-            for (const object of [...nodes, ...materials]) {
-                (0, babylonHelper_1.injectMetadata)(object, { tagManager: { parameters: { [parameter]: parameterValue } } }, false);
-            }
-            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;
-                // store old state in objects
-                for (const object of [...nodes, ...materials]) {
-                    (0, babylonHelper_1.injectMetadata)(object, { tagManager: { parameters: { [parameter]: oldValue } } }, false);
-                }
-            }
-            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;
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+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 viewerError_1 = require("../classes/viewerError");
+const babylonHelper_1 = require("../util/babylonHelper");
+const resourceHelper_1 = require("../util/resourceHelper");
+const tags_1 = require("@babylonjs/core/Misc/tags");
+const is_svg_1 = __importDefault(require("is-svg"));
+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.
+             */
+            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* () {
+            const visible = parameter_1.Parameter.parseBoolean(payload.newValue);
+            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.METALLIC, (payload) => __awaiter(this, void 0, void 0, function* () {
+            const metallic = parameter_1.Parameter.parseNumber(payload.newValue);
+            for (const material of payload.materials) {
+                const materialCls = material.getClassName();
+                switch (materialCls) {
+                    case 'PBRMaterial':
+                        material.metallic = metallic;
+                        break;
+                    default:
+                        throw new Error(`Setting metallic for material of instance "${materialCls}" not implemented (yet).`);
+                }
+            }
+            return true;
+        }));
+        this.parameterObservers.set(parameter_1.Parameter.PAINTABLE, (payload) => __awaiter(this, void 0, void 0, function* () {
+            const paintableValue = parameter_1.Parameter.parsePaintable(payload.newValue);
+            // check if value is svg or image source, do the conversion accordingly
+            const srcIsSvg = (0, is_svg_1.default)(paintableValue.src);
+            if (!srcIsSvg && paintableValue.src.includes('<svg') && paintableValue.src.includes('</svg>')) {
+                // seems like the user tried to use a SVG string, as <svg> tags are used
+                // inform the user that this is not a valid SVG string
+                throw new Error(`Setting paintable value failed: "${paintableValue.src}" is no valid SVG string.`);
+            }
+            let imageSource;
+            try {
+                imageSource = srcIsSvg
+                    ? yield (0, resourceHelper_1.createImageFromSvg)(paintableValue.src)
+                    : yield (0, resourceHelper_1.createImageFromImgSrc)(paintableValue.src);
+            }
+            catch (_a) {
+                // SVG might be invalid, even if it passes `isSvg` check
+                // in this case the image can't be created and will throw an error, which should be handled by the viewer and
+                // Combeenation viewer control
+                throw new viewerError_1.ViewerError({
+                    id: viewerError_1.ViewerErrorIds.InvalidParameterValue,
+                    message: `Invalid value for parameter "paintable" given:\nImage can't be created from source string.\nGiven value: ${paintableValue.src}`,
+                });
+            }
+            // apply image source on desired material(s)
+            for (const material of payload.materials) {
+                (0, babylonHelper_1.drawPaintableOnMaterial)(material, imageSource, this.viewer.scene, paintableValue.options);
+            }
+            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);
+            }
+            this.parameters.set(subject, parameterBag);
+            this.parameters.get(subject)[parameter] = parameterValue;
+            // get objects by subject and filter nodes by state
+            const nodes = this.getNodesBySubject(subject).filter(o => { var _a, _b, _c; return ((_c = (_b = (_a = o.metadata) === null || _a === void 0 ? void 0 : _a.tagManager) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c[parameter]) !== parameterValue; });
+            const materials = this.getMaterialsBySubject(subject).filter(o => { var _a, _b, _c; return ((_c = (_b = (_a = o.metadata) === null || _a === void 0 ? void 0 : _a.tagManager) === null || _b === void 0 ? void 0 : _b.parameters) === null || _c === void 0 ? void 0 : _c[parameter]) !== parameterValue; });
+            if (nodes.length === 0 && materials.length === 0) {
+                return Promise.resolve(parameterObserverResultBag);
+            }
+            // store state in objects
+            for (const object of [...nodes, ...materials]) {
+                (0, babylonHelper_1.injectMetadata)(object, { tagManager: { parameters: { [parameter]: parameterValue } } }, false);
+            }
+            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;
+                // store old state in objects
+                for (const object of [...nodes, ...materials]) {
+                    (0, babylonHelper_1.injectMetadata)(object, { tagManager: { parameters: { [parameter]: oldValue } } }, false);
+                }
+            }
+            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