@combeenation/3d-viewer 6.5.0 → 7.0.0-beta2

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

@@ -1,98 +1,98 @@
-"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.TextureLoadManager = void 0;
-const event_1 = require("../classes/event");
-const eventBroadcaster_1 = require("../classes/eventBroadcaster");
-const babylonHelper_1 = require("../util/babylonHelper");
-const resourceHelper_1 = require("../util/resourceHelper");
-/**
- * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
- * {@link Event.TEXTURE_LOADING_END} events.
- */
-class TextureLoadManager extends eventBroadcaster_1.EventBroadcaster {
-    constructor(scene) {
-        super();
-        this.scene = scene;
-        // We're keeping track of all "loading textures" in this map ourselves instead of relying on information from
-        // `scene.textures` as that proved to be rather unreliable for our use cases.
-        // E.g. see this forums post for some more information:
-        // https://forum.babylonjs.com/t/using-scene-createdefaultenvironment-removes-textures-from-scene/35267
-        this._loadingTextures = new Map();
-        // Whenever we fire the {@link Event.TEXTURE_LOADING_START} event, we're starting a polling service which checks all
-        // x ms if all awaited textures are in "ready state" or not.
-        // This is basically just an additional safety net in addition to our `onLoadObservable`s and was added to prevent
-        // situations where a {@link Event.TEXTURE_LOADING_START} event is fired without an accompanying
-        // {@link Event.TEXTURE_LOADING_END} as that is a situation which can lead to load masks being endlessly shown in a
-        // cfgr.
-        // In theory this shouldn't be necessary, but we've already discovered some quirks and inconsistent behavior around
-        // the texture load observables etc. and I felt more save with this safety net in place.
-        this._readyStatePollingIntervalMs = 200;
-        this._readyStatePollingId = 0;
-        this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
-    }
-    static create(scene) {
-        const loadMgr = new TextureLoadManager(scene);
-        return loadMgr;
-    }
-    startReadyStatePollingIfNeeded() {
-        if (!this._readyStatePollingId) {
-            this._readyStatePollingId = window.setInterval(() => this.checkLoadingTexturesState(), this._readyStatePollingIntervalMs);
-        }
-    }
-    endReadyStatePollingIfNeeded() {
-        if (this._readyStatePollingId) {
-            window.clearInterval(this._readyStatePollingId);
-            this._readyStatePollingId = 0;
-        }
-    }
-    /**
-     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
-     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
-     */
-    checkLoadingTexturesState() {
-        const allTexturesReadyBefore = !this._loadingTextures.size;
-        if (allTexturesReadyBefore)
-            return;
-        // Remove textures which are in "ready state" from the map
-        for (const [id, texture] of this._loadingTextures) {
-            if (texture.isReady())
-                this._loadingTextures.delete(id);
-        }
-        const allTexturesReadyAfter = !this._loadingTextures.size;
-        if (allTexturesReadyAfter) {
-            this.broadcastEvent(event_1.Event.TEXTURE_LOADING_END);
-            this.endReadyStatePollingIfNeeded();
-        }
-    }
-    onTextureAdded(texture) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Workaround:
-            // The texture object is not fully created when the "added observable" is called. E.g. the function
-            // `onLoadObservable` is not there at that point.
-            // More details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/4
-            yield (0, resourceHelper_1.sleep)(0);
-            // Some textures are already in "ready state" after the sleep -> We don't care for them anymore as well as for
-            // textures which don't come with an `onLoadObservable` (i.e. not of class {@link Texture}).
-            if (texture.isReady() || !(0, babylonHelper_1.isTextureWithOnLoadObservable)(texture))
-                return;
-            const noCurrentLoadingTextures = !this._loadingTextures.size;
-            if (noCurrentLoadingTextures) {
-                this.broadcastEvent(event_1.Event.TEXTURE_LOADING_START);
-                this.startReadyStatePollingIfNeeded();
-            }
-            this._loadingTextures.set(texture.uniqueId, texture);
-            texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
-        });
-    }
-}
-exports.TextureLoadManager = TextureLoadManager;
+"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.TextureLoadManager = void 0;
+const event_1 = require("../classes/event");
+const eventBroadcaster_1 = require("../classes/eventBroadcaster");
+const babylonHelper_1 = require("../util/babylonHelper");
+const resourceHelper_1 = require("../util/resourceHelper");
+/**
+ * Keeps track of all texture loading/ready states and fires {@link Event.TEXTURE_LOADING_START} and
+ * {@link Event.TEXTURE_LOADING_END} events.
+ */
+class TextureLoadManager extends eventBroadcaster_1.EventBroadcaster {
+    constructor(scene) {
+        super();
+        this.scene = scene;
+        // We're keeping track of all "loading textures" in this map ourselves instead of relying on information from
+        // `scene.textures` as that proved to be rather unreliable for our use cases.
+        // E.g. see this forums post for some more information:
+        // https://forum.babylonjs.com/t/using-scene-createdefaultenvironment-removes-textures-from-scene/35267
+        this._loadingTextures = new Map();
+        // Whenever we fire the {@link Event.TEXTURE_LOADING_START} event, we're starting a polling service which checks all
+        // x ms if all awaited textures are in "ready state" or not.
+        // This is basically just an additional safety net in addition to our `onLoadObservable`s and was added to prevent
+        // situations where a {@link Event.TEXTURE_LOADING_START} event is fired without an accompanying
+        // {@link Event.TEXTURE_LOADING_END} as that is a situation which can lead to load masks being endlessly shown in a
+        // cfgr.
+        // In theory this shouldn't be necessary, but we've already discovered some quirks and inconsistent behavior around
+        // the texture load observables etc. and I felt more save with this safety net in place.
+        this._readyStatePollingIntervalMs = 200;
+        this._readyStatePollingId = 0;
+        this.scene.onNewTextureAddedObservable.add(texture => this.onTextureAdded(texture));
+    }
+    static create(scene) {
+        const loadMgr = new TextureLoadManager(scene);
+        return loadMgr;
+    }
+    startReadyStatePollingIfNeeded() {
+        if (!this._readyStatePollingId) {
+            this._readyStatePollingId = window.setInterval(() => this.checkLoadingTexturesState(), this._readyStatePollingIntervalMs);
+        }
+    }
+    endReadyStatePollingIfNeeded() {
+        if (this._readyStatePollingId) {
+            window.clearInterval(this._readyStatePollingId);
+            this._readyStatePollingId = 0;
+        }
+    }
+    /**
+     * Checks the "ready state" of all textures inside the `this._loadingTextures` map, removes the ready ones and fires
+     * the {@link Event.TEXTURE_LOADING_END} event if no more textures are loading (i.e. "all ready").
+     */
+    checkLoadingTexturesState() {
+        const allTexturesReadyBefore = !this._loadingTextures.size;
+        if (allTexturesReadyBefore)
+            return;
+        // Remove textures which are in "ready state" from the map
+        for (const [id, texture] of this._loadingTextures) {
+            if (texture.isReady())
+                this._loadingTextures.delete(id);
+        }
+        const allTexturesReadyAfter = !this._loadingTextures.size;
+        if (allTexturesReadyAfter) {
+            this.broadcastEvent(event_1.Event.TEXTURE_LOADING_END);
+            this.endReadyStatePollingIfNeeded();
+        }
+    }
+    onTextureAdded(texture) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Workaround:
+            // The texture object is not fully created when the "added observable" is called. E.g. the function
+            // `onLoadObservable` is not there at that point.
+            // More details: https://forum.babylonjs.com/t/basetexture-whenallready-returns-too-early/34501/4
+            yield (0, resourceHelper_1.sleep)(0);
+            // Some textures are already in "ready state" after the sleep -> We don't care for them anymore as well as for
+            // textures which don't come with an `onLoadObservable` (i.e. not of class {@link Texture}).
+            if (texture.isReady() || !(0, babylonHelper_1.isTextureWithOnLoadObservable)(texture))
+                return;
+            const noCurrentLoadingTextures = !this._loadingTextures.size;
+            if (noCurrentLoadingTextures) {
+                this.broadcastEvent(event_1.Event.TEXTURE_LOADING_START);
+                this.startReadyStatePollingIfNeeded();
+            }
+            this._loadingTextures.set(texture.uniqueId, texture);
+            texture.onLoadObservable.addOnce(texture => this.checkLoadingTexturesState());
+        });
+    }
+}
+exports.TextureLoadManager = TextureLoadManager;
 //# sourceMappingURL=textureLoadManager.js.map

package/dist/lib-cjs/api/manager/variantInstanceManager.d.ts

@@ -1,92 +1,102 @@
-import { EventBroadcaster } from '../classes/eventBroadcaster';
-import { Variant } from '../classes/variant';
-import { VariantInstance } from '../classes/variantInstance';
-/**
- * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
- * {@link Viewer} instance via its {@link Viewer.variantInstances}
- */
-export declare class VariantInstanceManager extends EventBroadcaster {
-    protected rootVariant: Variant;
-    protected variantInstancePromises: Map<string, Promise<VariantInstance>>;
-    protected variantInstances: Map<string, VariantInstance>;
-    protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition>;
-    protected parameters: ParameterBag;
-    protected queues: {
-        [name: string]: Promise<VariantInstance>[];
-    };
-    /**
-     * Constructor.
-     */
-    protected constructor(rootVariant: Variant);
-    /**
-     * Creates a {@link VariantInstanceManager} based on given root Variant.
-     */
-    static create(rootVariant: Variant): Promise<VariantInstanceManager>;
-    /**
-     * Gets all instances.
-     */
-    get all(): VariantInstance[];
-    /**
-     * Gets all instance definitions.
-     */
-    get allDefinitions(): VariantInstanceDefinition[];
-    /**
-     * Checks whether a {@link VariantInstance} is either registered or created.
-     */
-    has(name: string): boolean;
-    /**
-     * Retrieves a {@link VariantInstance}.
-     * If the instance has been created, the created instance will be returned.
-     * If the instance is registered, the instance will be created and returned.
-     * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
-     * If none of these apply, an Error is thrown.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    get(name: string): Promise<VariantInstance>;
-    /**
-     * Creates and registers a unique {@link VariantInstance}.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    create(dottedPath: DottedPathArgument, name?: string, parameters?: ParameterBag): Promise<VariantInstance>;
-    /**
-     * Registers a unique {@link VariantInstanceDefinition}.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
-     */
-    register(instanceDefinition: VariantInstanceDefinition): VariantInstanceDefinition;
-    /**
-     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
-     */
-    commitParameters(parameters?: ParameterBag, onlyVisible?: boolean): Promise<VariantInstanceManager>;
-    /**
-     * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
-     * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
-     * the calls end up in a queue according to the FIFO principle (the last one wins).
-     */
-    show(name: string, exclusive?: boolean): Promise<VariantInstance>;
-    /**
-     * Clones and registers a new {@link VariantInstance} with a new, unique name.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
-     */
-    clone(name: string, newName: string, parameters?: ParameterBag): Promise<VariantInstance>;
-    /**
-     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
-     */
-    destroy(name: string): VariantInstanceManager;
-    /**
-     * Creates and registers a unique {@link VariantInstance} from `definition`.
-     *
-     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
-     */
-    protected createFromDefinition(definition: VariantInstanceDefinition): Promise<VariantInstance>;
-    /**
-     * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
-     * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
-     */
-    protected ensureUniqueName(name: string): string;
-}
+import { EventBroadcaster } from '../classes/eventBroadcaster';
+import { Variant } from '../classes/variant';
+import { VariantInstance } from '../classes/variantInstance';
+/**
+ * There's usually no need to instantiate a {@link VariantInstanceManager} yourself as it is provided by each
+ * {@link Viewer} instance via its {@link Viewer.variantInstances}
+ */
+export declare class VariantInstanceManager extends EventBroadcaster {
+    viewer: Viewer;
+    protected rootVariant: Variant;
+    protected variantInstancePromises: Map<string, Promise<VariantInstance>>;
+    protected variantInstances: Map<string, VariantInstance>;
+    protected variantInstanceDefinitions: Map<string, VariantInstanceDefinition>;
+    protected parameters: ParameterBag;
+    protected queues: {
+        [name: string]: Promise<VariantInstance>[];
+    };
+    /**
+     * Constructor.
+     */
+    protected constructor(viewer: Viewer, rootVariant: Variant);
+    /**
+     * Creates a {@link VariantInstanceManager} based on given root Variant.
+     */
+    static create(viewer: Viewer): Promise<VariantInstanceManager>;
+    /**
+     * Gets all instances.
+     */
+    get all(): VariantInstance[];
+    /**
+     * Gets all instance definitions.
+     */
+    get allDefinitions(): VariantInstanceDefinition[];
+    /**
+     * Gets all {@link VariantInstance}s with given {@link Variant}'s name.
+     */
+    allWithVariantName(name: string): VariantInstance[];
+    /**
+     * Checks whether a {@link VariantInstance} is either registered or created.
+     */
+    has(name: string): boolean;
+    /**
+     * Retrieves a {@link VariantInstance}.
+     * If the instance has been created, the created instance will be returned.
+     * If the instance is registered, the instance will be created and returned.
+     * if the instance has already been requested and is currently pending, the dedicated promise will be returned.
+     * If none of these apply, an Error is thrown.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    get(name: string): Promise<VariantInstance>;
+    /**
+     * Creates and registers a unique {@link VariantInstance}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    create(dottedPath: DottedPathArgument, name?: string, parameters?: ParameterBag): Promise<VariantInstance>;
+    /**
+     * Registers a unique {@link VariantInstanceDefinition}.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_REGISTERED}
+     */
+    register(instanceDefinition: VariantInstanceDefinition): VariantInstanceDefinition;
+    /**
+     * Commits the {@link ParameterBag} to all registered and created {@link VariantInstance}s.
+     */
+    commitParameters(parameters?: ParameterBag, onlyVisible?: boolean): Promise<VariantInstanceManager>;
+    /**
+     * Show one {@link VariantInstance}. If `exclusive` is set to `true` it will hide all other
+     * instances handled by this {@link VariantInstanceManager}. If the function is called synchronously,
+     * the calls end up in a queue according to the FIFO principle (the last one wins).
+     */
+    show(name: string, exclusive?: boolean): Promise<VariantInstance>;
+    /**
+     * Clones and registers a new {@link VariantInstance} with a new, unique name.
+     *
+     * @param tagMapping Object for renaming tags on the clone, whereas the "key" is the tag name of orignal variant
+     * instance and the "value" is the new tag name that should be created from it.\
+     * Check the docs of the tag managers [renaming](https://3dviewer.docs.combeenation.com/pages/documentation/Tag-Manager.html#uniqueness-of-node-and-tag-names)
+     * chapter for further details.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CLONED}
+     */
+    clone(name: string, newName: string, parameters?: ParameterBag, tagMapping?: TagMapping): Promise<VariantInstance>;
+    /**
+     * Destroys the instance by removing the {@link Variant} and de-registering the instance.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_DESTROYED}
+     */
+    destroy(name: string): VariantInstanceManager;
+    /**
+     * Creates and registers a unique {@link VariantInstance} from `definition`.
+     *
+     * @emits {@link Event.VARIANT_INSTANCE_CREATED}
+     */
+    protected createFromDefinition(definition: VariantInstanceDefinition): Promise<VariantInstance>;
+    /**
+     * Creates a unique instance name based on already registered instance names on the {@link VariantInstanceManager}.
+     * Appends an `_i` to the name where `i = 0` and increments as long as the name is not registered.
+     */
+    protected ensureUniqueName(name: string): string;
+}