@babylonjs/viewer 5.0.0 → 5.0.3

package/configuration/mappers.js

@@ -1,191 +1,191 @@
-import { Tools } from "@babylonjs/core/Misc/tools.js";
-// eslint-disable-next-line import/no-internal-modules
-import { kebabToCamel } from "../helper/index.js";
-/**
- * This is a simple HTML mapper.
- * This mapper parses a single HTML element and returns the configuration from its attributes.
- * it parses numbers and boolean values to the corresponding variable types.
- * The following HTML element:
- *  <div test="1" random-flag="true" a.string.object="test"> will result in the following configuration:
- *
- *  {
- *      test: 1, //a number!
- *      randomFlag: boolean, //camelCase and boolean
- *      a: {
- *          string: {
- *              object: "test" //dot-separated object levels
- *          }
- *      }
- *  }
- */
-var HTMLMapper = /** @class */ (function () {
-    function HTMLMapper() {
-    }
-    /**
-     * Map a specific element and get configuration from it
-     * @param element the HTML element to analyze.
-     */
-    HTMLMapper.prototype.map = function (element) {
-        var config = {};
-        var _loop_1 = function (attrIdx) {
-            var attr = element.attributes.item(attrIdx);
-            if (!attr) {
-                return "continue";
-            }
-            // map "object.property" to the right configuration place.
-            var split = attr.nodeName.split(".");
-            split.reduce(function (currentConfig, key, idx) {
-                //convert html-style to json-style
-                var camelKey = kebabToCamel(key);
-                if (idx === split.length - 1) {
-                    var val = attr.nodeValue; // firefox warns nodeValue is deprecated, but I found no sign of it anywhere.
-                    if (val === "true") {
-                        val = true;
-                    }
-                    else if (val === "false") {
-                        val = false;
-                    }
-                    else if (val === "undefined") {
-                        val = undefined;
-                    }
-                    else if (val === "null") {
-                        val = null;
-                    }
-                    else {
-                        var isnum = !isNaN(parseFloat(val)) && isFinite(val); ///^\d+$/.test(val);
-                        if (isnum) {
-                            var number = parseFloat(val);
-                            if (!isNaN(number)) {
-                                val = number;
-                            }
-                        }
-                    }
-                    currentConfig[camelKey] = val;
-                }
-                else {
-                    currentConfig[camelKey] = currentConfig[camelKey] || {};
-                }
-                return currentConfig[camelKey];
-            }, config);
-        };
-        for (var attrIdx = 0; attrIdx < element.attributes.length; ++attrIdx) {
-            _loop_1(attrIdx);
-        }
-        return config;
-    };
-    return HTMLMapper;
-}());
-/**
- * A simple string-to-JSON mapper.
- * This is the main mapper, used to analyze downloaded JSON-Configuration or JSON payload
- */
-var JSONMapper = /** @class */ (function () {
-    function JSONMapper() {
-    }
-    JSONMapper.prototype.map = function (rawSource) {
-        return JSON.parse(rawSource);
-    };
-    return JSONMapper;
-}());
-/**
- * The DOM Mapper will traverse an entire DOM Tree and will load the configuration from the
- * DOM elements and attributes.
- */
-var DOMMapper = /** @class */ (function () {
-    function DOMMapper() {
-    }
-    /**
-     * The mapping function that will convert HTML data to a viewer configuration object
-     * @param baseElement the baseElement from which to start traversing
-     * @returns a ViewerConfiguration object from the provided HTML Element
-     */
-    DOMMapper.prototype.map = function (baseElement) {
-        var htmlMapper = new HTMLMapper();
-        var config = htmlMapper.map(baseElement);
-        var traverseChildren = function (element, partConfig) {
-            var children = element.children;
-            if (children.length) {
-                for (var i = 0; i < children.length; ++i) {
-                    var item = children.item(i);
-                    // use the HTML Mapper to read configuration from a single element
-                    var configMapped = htmlMapper.map(item);
-                    var key = kebabToCamel(item.nodeName.toLowerCase());
-                    if (item.attributes.getNamedItem("array") && item.attributes.getNamedItem("array").nodeValue === "true") {
-                        partConfig[key] = [];
-                    }
-                    else {
-                        if (element.attributes.getNamedItem("array") && element.attributes.getNamedItem("array").nodeValue === "true") {
-                            partConfig.push(configMapped);
-                        }
-                        else if (partConfig[key]) {
-                            //exists already! probably an array
-                            element.setAttribute("array", "true");
-                            var oldItem = partConfig[key];
-                            partConfig = [oldItem, configMapped];
-                        }
-                        else {
-                            partConfig[key] = configMapped;
-                        }
-                    }
-                    traverseChildren(item, partConfig[key] || configMapped);
-                }
-            }
-            return partConfig;
-        };
-        traverseChildren(baseElement, config);
-        return config;
-    };
-    return DOMMapper;
-}());
-/**
- * The MapperManager manages the different implemented mappers.
- * It allows the user to register new mappers as well and use them to parse their own configuration data
- */
-var MapperManager = /** @class */ (function () {
-    function MapperManager() {
-        this._mappers = {
-            html: new HTMLMapper(),
-            json: new JSONMapper(),
-            dom: new DOMMapper(),
-        };
-    }
-    /**
-     * Get a specific configuration mapper.
-     *
-     * @param type the name of the mapper to load
-     */
-    MapperManager.prototype.getMapper = function (type) {
-        if (!this._mappers[type]) {
-            Tools.Error("No mapper defined for " + type);
-        }
-        return this._mappers[type];
-    };
-    /**
-     * Use this function to register your own configuration mapper.
-     * After a mapper is registered, it can be used to parse the specific type fo configuration to the standard ViewerConfiguration.
-     * @param type the name of the mapper. This will be used to define the configuration type and/or to get the mapper
-     * @param mapper The implemented mapper
-     */
-    MapperManager.prototype.registerMapper = function (type, mapper) {
-        this._mappers[type] = mapper;
-    };
-    /**
-     * Dispose the mapper manager and all of its mappers.
-     */
-    MapperManager.prototype.dispose = function () {
-        this._mappers = {};
-    };
-    /**
-     * The default mapper is the JSON mapper.
-     */
-    MapperManager.DefaultMapper = "json";
-    return MapperManager;
-}());
-export { MapperManager };
-/**
- * mapperManager is a singleton of the type MapperManager.
- * The mapperManager can be disposed directly with calling mapperManager.dispose()
- * or indirectly with using BabylonViewer.disposeAll()
- */
-export var mapperManager = new MapperManager();
+import { Tools } from "@babylonjs/core/Misc/tools.js";
+// eslint-disable-next-line import/no-internal-modules
+import { kebabToCamel } from "../helper/index.js";
+/**
+ * This is a simple HTML mapper.
+ * This mapper parses a single HTML element and returns the configuration from its attributes.
+ * it parses numbers and boolean values to the corresponding variable types.
+ * The following HTML element:
+ *  <div test="1" random-flag="true" a.string.object="test"> will result in the following configuration:
+ *
+ *  {
+ *      test: 1, //a number!
+ *      randomFlag: boolean, //camelCase and boolean
+ *      a: {
+ *          string: {
+ *              object: "test" //dot-separated object levels
+ *          }
+ *      }
+ *  }
+ */
+var HTMLMapper = /** @class */ (function () {
+    function HTMLMapper() {
+    }
+    /**
+     * Map a specific element and get configuration from it
+     * @param element the HTML element to analyze.
+     */
+    HTMLMapper.prototype.map = function (element) {
+        var config = {};
+        var _loop_1 = function (attrIdx) {
+            var attr = element.attributes.item(attrIdx);
+            if (!attr) {
+                return "continue";
+            }
+            // map "object.property" to the right configuration place.
+            var split = attr.nodeName.split(".");
+            split.reduce(function (currentConfig, key, idx) {
+                //convert html-style to json-style
+                var camelKey = kebabToCamel(key);
+                if (idx === split.length - 1) {
+                    var val = attr.nodeValue; // firefox warns nodeValue is deprecated, but I found no sign of it anywhere.
+                    if (val === "true") {
+                        val = true;
+                    }
+                    else if (val === "false") {
+                        val = false;
+                    }
+                    else if (val === "undefined") {
+                        val = undefined;
+                    }
+                    else if (val === "null") {
+                        val = null;
+                    }
+                    else {
+                        var isnum = !isNaN(parseFloat(val)) && isFinite(val); ///^\d+$/.test(val);
+                        if (isnum) {
+                            var number = parseFloat(val);
+                            if (!isNaN(number)) {
+                                val = number;
+                            }
+                        }
+                    }
+                    currentConfig[camelKey] = val;
+                }
+                else {
+                    currentConfig[camelKey] = currentConfig[camelKey] || {};
+                }
+                return currentConfig[camelKey];
+            }, config);
+        };
+        for (var attrIdx = 0; attrIdx < element.attributes.length; ++attrIdx) {
+            _loop_1(attrIdx);
+        }
+        return config;
+    };
+    return HTMLMapper;
+}());
+/**
+ * A simple string-to-JSON mapper.
+ * This is the main mapper, used to analyze downloaded JSON-Configuration or JSON payload
+ */
+var JSONMapper = /** @class */ (function () {
+    function JSONMapper() {
+    }
+    JSONMapper.prototype.map = function (rawSource) {
+        return JSON.parse(rawSource);
+    };
+    return JSONMapper;
+}());
+/**
+ * The DOM Mapper will traverse an entire DOM Tree and will load the configuration from the
+ * DOM elements and attributes.
+ */
+var DOMMapper = /** @class */ (function () {
+    function DOMMapper() {
+    }
+    /**
+     * The mapping function that will convert HTML data to a viewer configuration object
+     * @param baseElement the baseElement from which to start traversing
+     * @returns a ViewerConfiguration object from the provided HTML Element
+     */
+    DOMMapper.prototype.map = function (baseElement) {
+        var htmlMapper = new HTMLMapper();
+        var config = htmlMapper.map(baseElement);
+        var traverseChildren = function (element, partConfig) {
+            var children = element.children;
+            if (children.length) {
+                for (var i = 0; i < children.length; ++i) {
+                    var item = children.item(i);
+                    // use the HTML Mapper to read configuration from a single element
+                    var configMapped = htmlMapper.map(item);
+                    var key = kebabToCamel(item.nodeName.toLowerCase());
+                    if (item.attributes.getNamedItem("array") && item.attributes.getNamedItem("array").nodeValue === "true") {
+                        partConfig[key] = [];
+                    }
+                    else {
+                        if (element.attributes.getNamedItem("array") && element.attributes.getNamedItem("array").nodeValue === "true") {
+                            partConfig.push(configMapped);
+                        }
+                        else if (partConfig[key]) {
+                            //exists already! probably an array
+                            element.setAttribute("array", "true");
+                            var oldItem = partConfig[key];
+                            partConfig = [oldItem, configMapped];
+                        }
+                        else {
+                            partConfig[key] = configMapped;
+                        }
+                    }
+                    traverseChildren(item, partConfig[key] || configMapped);
+                }
+            }
+            return partConfig;
+        };
+        traverseChildren(baseElement, config);
+        return config;
+    };
+    return DOMMapper;
+}());
+/**
+ * The MapperManager manages the different implemented mappers.
+ * It allows the user to register new mappers as well and use them to parse their own configuration data
+ */
+var MapperManager = /** @class */ (function () {
+    function MapperManager() {
+        this._mappers = {
+            html: new HTMLMapper(),
+            json: new JSONMapper(),
+            dom: new DOMMapper(),
+        };
+    }
+    /**
+     * Get a specific configuration mapper.
+     *
+     * @param type the name of the mapper to load
+     */
+    MapperManager.prototype.getMapper = function (type) {
+        if (!this._mappers[type]) {
+            Tools.Error("No mapper defined for " + type);
+        }
+        return this._mappers[type];
+    };
+    /**
+     * Use this function to register your own configuration mapper.
+     * After a mapper is registered, it can be used to parse the specific type fo configuration to the standard ViewerConfiguration.
+     * @param type the name of the mapper. This will be used to define the configuration type and/or to get the mapper
+     * @param mapper The implemented mapper
+     */
+    MapperManager.prototype.registerMapper = function (type, mapper) {
+        this._mappers[type] = mapper;
+    };
+    /**
+     * Dispose the mapper manager and all of its mappers.
+     */
+    MapperManager.prototype.dispose = function () {
+        this._mappers = {};
+    };
+    /**
+     * The default mapper is the JSON mapper.
+     */
+    MapperManager.DefaultMapper = "json";
+    return MapperManager;
+}());
+export { MapperManager };
+/**
+ * mapperManager is a singleton of the type MapperManager.
+ * The mapperManager can be disposed directly with calling mapperManager.dispose()
+ * or indirectly with using BabylonViewer.disposeAll()
+ */
+export var mapperManager = new MapperManager();
 //# sourceMappingURL=mappers.js.map

package/configuration/renderOnlyLoader.d.ts

@@ -1,33 +1,33 @@
-import type { ViewerConfiguration } from "./configuration";
-/**
- * The configuration loader will load the configuration object from any source and will use the defined mapper to
- * parse the object and return a conform ViewerConfiguration.
- * It is a private member of the scene.
- */
-export declare class RenderOnlyConfigurationLoader {
-    private _enableCache;
-    private _configurationCache;
-    private _loadRequests;
-    constructor(_enableCache?: boolean);
-    private _getConfigurationTypeExcludeTemplate;
-    protected getExtendedConfig(type: string | undefined): ViewerConfiguration;
-    /**
-     * load a configuration object that is defined in the initial configuration provided.
-     * The viewer configuration can extend different types of configuration objects and have an extra configuration defined.
-     *
-     * @param initConfig the initial configuration that has the definitions of further configuration to load.
-     * @param callback an optional callback that will be called sync, if noconfiguration needs to be loaded or configuration is payload-only
-     * @returns A promise that delivers the extended viewer configuration, when done.
-     */
-    loadConfiguration(initConfig?: ViewerConfiguration, callback?: (config: ViewerConfiguration) => void): Promise<ViewerConfiguration>;
-    /**
-     * Dispose the configuration loader. This will cancel file requests, if active.
-     */
-    dispose(): void;
-    /**
-     * This function will process the initial configuration and make needed changes for the viewer to work.
-     * @param config the mutable(!) initial configuration to process
-     */
-    private _processInitialConfiguration;
-    private _loadFile;
-}
+import type { ViewerConfiguration } from "./configuration";
+/**
+ * The configuration loader will load the configuration object from any source and will use the defined mapper to
+ * parse the object and return a conform ViewerConfiguration.
+ * It is a private member of the scene.
+ */
+export declare class RenderOnlyConfigurationLoader {
+    private _enableCache;
+    private _configurationCache;
+    private _loadRequests;
+    constructor(_enableCache?: boolean);
+    private _getConfigurationTypeExcludeTemplate;
+    protected getExtendedConfig(type: string | undefined): ViewerConfiguration;
+    /**
+     * load a configuration object that is defined in the initial configuration provided.
+     * The viewer configuration can extend different types of configuration objects and have an extra configuration defined.
+     *
+     * @param initConfig the initial configuration that has the definitions of further configuration to load.
+     * @param callback an optional callback that will be called sync, if noconfiguration needs to be loaded or configuration is payload-only
+     * @returns A promise that delivers the extended viewer configuration, when done.
+     */
+    loadConfiguration(initConfig?: ViewerConfiguration, callback?: (config: ViewerConfiguration) => void): Promise<ViewerConfiguration>;
+    /**
+     * Dispose the configuration loader. This will cancel file requests, if active.
+     */
+    dispose(): void;
+    /**
+     * This function will process the initial configuration and make needed changes for the viewer to work.
+     * @param config the mutable(!) initial configuration to process
+     */
+    private _processInitialConfiguration;
+    private _loadFile;
+}