@schukai/monster 3.48.0 → 3.50.0

package/source/dom/customelement.mjs

@@ -5,37 +5,37 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-import {findElementWithIdUpwards} from "./util.mjs";
-import {internalSymbol} from "../constants.mjs";
-import {extend} from "../data/extend.mjs";
-import {Pathfinder} from "../data/pathfinder.mjs";
-import {Formatter} from "../text/formatter.mjs";
-
-import {parseDataURL} from "../types/dataurl.mjs";
-import {getGlobalObject} from "../types/global.mjs";
-import {isArray, isFunction, isIterable, isObject, isString} from "../types/is.mjs";
-import {Observer} from "../types/observer.mjs";
-import {ProxyObserver} from "../types/proxyobserver.mjs";
-import {validateFunction, validateInstance, validateObject, validateString} from "../types/validate.mjs";
-import {clone} from "../util/clone.mjs";
-import {addAttributeToken, getLinkedObjects, hasObjectLink} from "./attributes.mjs";
+import { findElementWithIdUpwards } from "./util.mjs";
+import { internalSymbol } from "../constants.mjs";
+import { extend } from "../data/extend.mjs";
+import { Pathfinder } from "../data/pathfinder.mjs";
+import { Formatter } from "../text/formatter.mjs";
+
+import { parseDataURL } from "../types/dataurl.mjs";
+import { getGlobalObject } from "../types/global.mjs";
+import { isArray, isFunction, isIterable, isObject, isString } from "../types/is.mjs";
+import { Observer } from "../types/observer.mjs";
+import { ProxyObserver } from "../types/proxyobserver.mjs";
+import { validateFunction, validateInstance, validateObject, validateString } from "../types/validate.mjs";
+import { clone } from "../util/clone.mjs";
+import { addAttributeToken, getLinkedObjects, hasObjectLink } from "./attributes.mjs";
 import {
     ATTRIBUTE_DISABLED,
     ATTRIBUTE_ERRORMESSAGE,
     ATTRIBUTE_OPTIONS,
-    ATTRIBUTE_OPTION_CALLBACK,
+    ATTRIBUTE_INIT_CALLBACK,
     ATTRIBUTE_OPTIONS_SELECTOR,
     ATTRIBUTE_SCRIPT_HOST,
     customElementUpdaterLinkSymbol,
-    initControlCallbackName
+    initControlCallbackName,
 } from "./constants.mjs";
-import {findDocumentTemplate, Template} from "./template.mjs";
-import {addObjectWithUpdaterToElement} from "./updater.mjs";
-import {instanceSymbol} from "../constants.mjs";
-import {getDocumentTranslations, Translations} from "../i18n/translations.mjs";
-import {getSlottedElements} from "./slotted.mjs";
-import {initOptionsFromAttributes} from "./util/init-options-from-attributes.mjs";
-import {setOptionFromAttribute} from "./util/set-option-from-attribute.mjs";
+import { findDocumentTemplate, Template } from "./template.mjs";
+import { addObjectWithUpdaterToElement } from "./updater.mjs";
+import { instanceSymbol } from "../constants.mjs";
+import { getDocumentTranslations, Translations } from "../i18n/translations.mjs";
+import { getSlottedElements } from "./slotted.mjs";
+import { initOptionsFromAttributes } from "./util/init-options-from-attributes.mjs";
+import { setOptionFromAttribute } from "./util/set-option-from-attribute.mjs";
 
 export {
     CustomElement,
@@ -121,15 +121,12 @@ const scriptHostElementSymbol = Symbol("scriptHostElement");
  */
 
 /**
- * To define a new HTML element we need the power of CustomElement
+ * The `CustomElement` class provides a way to define a new HTML element using the power of Custom Elements.
  *
- * IMPORTANT: after defining a `CustomElement`, the `registerCustomElement` method must be called
- * with the new class name. only then will the tag defined via the `getTag` method be made known to the DOM.
- *
- * <img src="./images/customelement-class.png">
- *
- * You can create the object via the function `document.createElement()`.
+ * **IMPORTANT:** After defining a `CustomElement`, the `registerCustomElement` method must be called with the new class name
+ * to make the tag defined via the `getTag` method known to the DOM.
  *
+ * You can create an instance of the object via the `document.createElement()` function.
  *
  * ## Interaction
  *
@@ -137,15 +134,13 @@ const scriptHostElementSymbol = Symbol("scriptHostElement");
  *
  * ## Styling
  *
- * For optimal display of custom-elements the pseudo-class :defined can be used.
+ * To display custom elements optimally, the `:defined` pseudo-class can be used. To prevent custom elements from being displayed and flickering until the control is registered,
+ * it is recommended to create a CSS directive.
  *
- * To prevent the custom elements from being displayed and flickering until the control is registered, it is recommended to create a css directive.
+ * In the simplest case, you can simply hide the control:
  *
- * In the simplest case, you can simply hide the control.
- *
- * ```
+ * ```html
  * <style>
- *
  * my-custom-element:not(:defined) {
  *     display: none;
  * }
@@ -153,63 +148,65 @@ const scriptHostElementSymbol = Symbol("scriptHostElement");
  * my-custom-element:defined {
  *     display: flex;
  * }
- *
  * </style>
  * ```
  *
- * Alternatively you can also display a loader
+ * Alternatively, you can display a loader:
  *
- * ```
+ * ```css
  * my-custom-element:not(:defined) {
- *            display: flex;
- *            box-shadow: 0 4px 10px 0 rgba(33, 33, 33, 0.15);
- *            border-radius: 4px;
- *            height: 200px;
- *            position: relative;
- *            overflow: hidden;
- *        }
+ *     display: flex;
+ *     box-shadow: 0 4px 10px 0 rgba(33, 33, 33, 0.15);
+ *     border-radius: 4px;
+ *     height: 200px;
+ *     position: relative;
+ *     overflow: hidden;
+ * }
  *
  * my-custom-element:not(:defined)::before {
- *            content: '';
- *            display: block;
- *            position: absolute;
- *            left: -150px;
- *            top: 0;
- *            height: 100%;
- *            width: 150px;
- *            background: linear-gradient(to right, transparent 0%, #E8E8E8 50%, transparent 100%);
- *            animation: load 1s cubic-bezier(0.4, 0.0, 0.2, 1) infinite;
- *        }
+ *     content: '';
+ *     display: block;
+ *     position: absolute;
+ *     left: -150px;
+ *     top: 0;
+ *     height: 100%;
+ *     width: 150px;
+ *     background: linear-gradient(to right, transparent 0%, #E8E8E8 50%, transparent 100%);
+ *     animation: load 1s cubic-bezier(0.4, 0.0, 0.2, 1) infinite;
+ * }
  *
  * @keyframes load {
- *            from {
- *                left: -150px;
- *            }
- *            to   {
- *                left: 100%;
- *            }
- *        }
+ *     from {
+ *         left: -150px;
+ *     }
+ *     to {
+ *         left: 100%;
+ *     }
+ * }
  *
  * my-custom-element:defined {
- *           display: flex;
- *       }
+ *     display: flex;
+ * }
  * ```
  *
+ * More information about Custom Elements can be found in the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_custom_elements).
+ * And in the [HTML Standard](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) or in the [WHATWG Wiki](https://wiki.whatwg.org/wiki/Custom_Elements).
+ *
  * @externalExample ../../example/dom/theme.mjs
- * @see https://github.com/WICG/webcomponents
- * @see https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements
  * @license AGPLv3
  * @since 1.7.0
  * @copyright schukai GmbH
  * @memberOf Monster.DOM
  * @extends external:HTMLElement
- * @summary A base class for HTML5 customcontrols
+ * @summary A base class for HTML5 custom controls.
  */
 class CustomElement extends HTMLElement {
     /**
      * A new object is created. First the `initOptions` method is called. Here the
      * options can be defined in derived classes. Subsequently, the shadowRoot is initialized.
      *
+     * IMPORTANT: CustomControls instances are not created via the constructor, but either via a tag in the HTML or via <code>document.createElement()</code>.
+     *
      * @throws {Error} the options attribute does not contain a valid json definition.
      * @since 1.7.0
      */
@@ -223,7 +220,6 @@ class CustomElement extends HTMLElement {
         this[initMethodSymbol]();
         initOptionObserver.call(this);
         this[scriptHostElementSymbol] = [];
-
     }
 
     /**
@@ -270,53 +266,25 @@ class CustomElement extends HTMLElement {
     }
 
     /**
-     * Derived classes can override and extend this method as follows.
+     * The `defaults` property defines the default values for a control. If you want to override these,
+     * you can use various methods, which are described in the documentation available at
+     * {@link https://monsterjs.orgendocconfigurate-a-monster-control}.
      *
-     * ```
-     * get defaults() {
-     *    return Object.assign({}, super.defaults, {
-     *        myValue:true
-     *    });
-     * }
-     * ```
-     *
-     * To set the options via the html tag the attribute data-monster-options must be set.
-     * As value a JSON object with the desired values must be defined.
-     *
-     * Since 1.18.0 the JSON can be specified as a DataURI.
-     *
-     * ```
-     * new Monster.Types.DataUrl(btoa(JSON.stringify({
-     *        shadowMode: 'open',
-     *        delegatesFocus: true,
-     *        templates: {
-     *            main: undefined
-     *        }
-     *    })),'application/json',true).toString()
-     * ```
+     * The individual configuration values are listed below:
      *
-     * The attribute data-monster-options-selector can be used to access a script tag that contains additional configuration.
+     * More information about the shadowRoot can be found in the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/API/Element/attachShadow),
+     * in the [HTML Standard](https://html.spec.whatwg.org/multipage/custom-elements.html#custom-elements) or in the [WHATWG Wiki](https://wiki.whatwg.org/wiki/Custom_Elements).
      *
-     * As value a selector must be specified, which belongs to a script tag and contains the configuration as json.
+     * More information about the template element can be found in the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/template).
      *
-     * ```
-     * <script id="id-for-this-config" type="application/json">
-     *    {
-     *        "config-key": "config-value"
-     *    }
-     * </script>
-     * ```
-     *
-     * The individual configuration values can be found in the table.
-     *
-     * @property {boolean} disabled=false Object The Boolean disabled attribute, when present, makes the element not mutable, focusable, or even submitted with the form.
-     * @property {string} shadowMode=open `open` Elements of the shadow root are accessible from JavaScript outside the root, for example using. `close` Denies access to the node(s) of a closed shadow root from JavaScript outside it
-     * @property {Boolean} delegatesFocus=true A boolean that, when set to true, specifies behavior that mitigates custom element issues around focusability. When a non-focusable part of the shadow DOM is clicked, the first focusable part is given focus, and the shadow host is given any available :focus styling.
-     * @property {Object} templates Templates
-     * @property {string} templates.main=undefined Main template
-     * @property {Object} templateMapping Template mapping
+     * More information about the slot element can be found in the [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/slot).
      *
-     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/attachShadow
+     * @property {boolean} disabled=false Specifies whether the control is disabled. When present, it makes the element non-mutable, non-focusable, and non-submittable with the form.
+     * @property {string} shadowMode=open Specifies the mode of the shadow root. When set to `open`, elements in the shadow root are accessible from JavaScript outside the root, while setting it to `closed` denies access to the root's nodes from JavaScript outside it.
+     * @property {Boolean} delegatesFocus=true Specifies the behavior of the control with respect to focusability. When set to `true`, it mitigates custom element issues around focusability. When a non-focusable part of the shadow DOM is clicked, the first focusable part is given focus, and the shadow host is given any available :focus styling.
+     * @property {Object} templates Specifies the templates used by the control.
+     * @property {string} templates.main=undefined Specifies the main template used by the control.
+     * @property {Object} templateMapping Specifies the mapping of templates.
      * @since 1.8.0
      */
     get defaults() {
@@ -383,39 +351,51 @@ class CustomElement extends HTMLElement {
     }
 
     /**
-     * There is no check on the name by this class. the developer is responsible for assigning an appropriate tag.
-     * if the name is not valid, registerCustomElement() will issue an error
+     * The `getTag()` method returns the tag name associated with the custom element. This method should be overwritten
+     * by the derived class.
      *
-     * @link https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
-     * @return {string}
-     * @throws {Error} the method getTag must be overwritten by the derived class.
+     * Note that there is no check on the name of the tag in this class. It is the responsibility of
+     * the developer to assign an appropriate tag name. If the name is not valid, the
+     * `registerCustomElement()` method will issue an error.
+     *
+     * @see https://html.spec.whatwg.org/multipage/custom-elements.html#valid-custom-element-name
+     * @throws {Error} This method must be overridden by the derived class.
+     * @return {string} The tag name associated with the custom element.
      * @since 1.7.0
      */
     static getTag() {
-        throw new Error("the method getTag must be overwritten by the derived class.");
+        throw new Error("The method `getTag()` must be overridden by the derived class.");
     }
 
     /**
-     * At this point a `CSSStyleSheet` object can be returned. If the environment does not
-     * support a constructor, then an object can also be built using the following detour.
+     * The `getCSSStyleSheet()` method returns a `CSSStyleSheet` object that defines the styles for the custom element.
+     * If the environment does not support the `CSSStyleSheet` constructor, then an object can be built using the provided detour.
+     *
+     * If `undefined` is returned, then the shadow root does not receive a stylesheet.
      *
-     * If `undefined` is returned then the shadowRoot does not get a stylesheet.
+     * Example usage:
      *
+     * ```js
+     * static getCSSStyleSheet() {
+     *     const sheet = new CSSStyleSheet();
+     *     sheet.replaceSync("p { color: red; }");
+     *     return sheet;
+     * }
      * ```
-     * const doc = document.implementation.createHTMLDocument('title');
      *
-     * let style = doc.createElement("style");
-     * style.innerHTML="p{color:red;}";
+     * If the environment does not support the `CSSStyleSheet` constructor,
+     * you can use the following workaround to create the stylesheet:
      *
-     * // WebKit Hack
+     * ```js
+     * const doc = document.implementation.createHTMLDocument('title');
+     * let style = doc.createElement("style");
+     * style.innerHTML = "p { color: red; }";
      * style.appendChild(document.createTextNode(""));
-     * // Add the <style> element to the page
      * doc.head.appendChild(style);
      * return doc.styleSheets[0];
-     * ;
      * ```
      *
-     * @return {CSSStyleSheet|CSSStyleSheet[]|string|undefined}
+     * @return {CSSStyleSheet|CSSStyleSheet[]|string|undefined} A `CSSStyleSheet` object or an array of such objects that define the styles for the custom element, or `undefined` if no stylesheet should be applied.
      */
     static getCSSStyleSheet() {
         return undefined;
@@ -464,8 +444,7 @@ class CustomElement extends HTMLElement {
 
         try {
             value = new Pathfinder(this[internalSymbol].getRealSubject()["options"]).getVia(path);
-        } catch (e) {
-        }
+        } catch (e) {}
 
         if (value === undefined) return defaultValue;
         return value;
@@ -511,9 +490,14 @@ class CustomElement extends HTMLElement {
     }
 
     /**
-     * Is called once when the object is included in the DOM for the first time.
+     * This method is called once when the object is included in the DOM for the first time. It performs the following actions:
+     * 1. Extracts the options from the attributes and the script tag of the element and sets them.
+     * 2. Initializes the shadow root and its CSS stylesheet (if specified).
+     * 3. Initializes the HTML content of the element.
+     * 4. Initializes the custom elements inside the shadow root and the slotted elements.
+     * 5. Attaches a mutation observer to observe changes to the attributes of the element.
      *
-     * @return {CustomElement}
+     * @return {CustomElement} - The updated custom element.
      * @since 1.8.0
      */
     [assembleMethodSymbol]() {
@@ -521,22 +505,25 @@ class CustomElement extends HTMLElement {
         let elements;
         let nodeList;
 
+        // Extract options from attributes and set them
         const AttributeOptions = getOptionsFromAttributes.call(self);
         if (isObject(AttributeOptions) && Object.keys(AttributeOptions).length > 0) {
             self.setOptions(AttributeOptions);
         }
 
+        // Extract options from script tag and set them
         const ScriptOptions = getOptionsFromScriptTag.call(self);
         if (isObject(ScriptOptions) && Object.keys(ScriptOptions).length > 0) {
             self.setOptions(ScriptOptions);
         }
 
-
+        // Initialize the shadow root and its CSS stylesheet
         if (self.getOption("shadowMode", false) !== false) {
             try {
                 initShadowRoot.call(self);
                 elements = self.shadowRoot.childNodes;
             } catch (e) {
+                addAttributeToken(self, ATTRIBUTE_ERRORMESSAGE, e.toString());
             }
 
             try {
@@ -546,21 +533,19 @@ class CustomElement extends HTMLElement {
             }
         }
 
+        // If the elements are not found inside the shadow root, initialize the HTML content of the element
         if (!(elements instanceof NodeList)) {
-            if (!(elements instanceof NodeList)) {
-                initHtmlContent.call(this);
-                elements = this.childNodes;
-            }
+            initHtmlContent.call(this);
+            elements = this.childNodes;
         }
 
+        // Initialize the custom elements inside the shadow root and the slotted elements
         initFromCallbackHost.call(this);
-
         try {
             nodeList = new Set([...elements, ...getSlottedElements.call(self)]);
         } catch (e) {
             nodeList = elements;
         }
-
         addObjectWithUpdaterToElement.call(
             self,
             nodeList,
@@ -568,24 +553,28 @@ class CustomElement extends HTMLElement {
             clone(self[internalSymbol].getRealSubject()["options"]),
         );
 
+        // Attach a mutation observer to observe changes to the attributes of the element
         attachAttributeChangeMutationObserver.call(this);
 
         return self;
     }
 
     /**
-     * Called every time the element is inserted into the DOM. Useful for running setup code, such as
-     * fetching resources or rendering. Generally, you should try to delay work until this time.
+     * This method is called every time the element is inserted into the DOM. It checks if the custom element
+     * has already been initialized and if not, calls the assembleMethod to initialize it.
      *
      * @return {void}
      * @since 1.7.0
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/connectedCallback
      */
     connectedCallback() {
-        let self = this;
+        const self = this;
+
+        // Check if the object has already been initialized
         if (!hasObjectLink(self, customElementUpdaterLinkSymbol)) {
+            // If not, call the assembleMethod to initialize the object
             self[assembleMethodSymbol]();
         }
-
     }
 
     /**
@@ -594,8 +583,7 @@ class CustomElement extends HTMLElement {
      * @return {void}
      * @since 1.7.0
      */
-    disconnectedCallback() {
-    }
+    disconnectedCallback() {}
 
     /**
      * The custom element has been moved into a new document (e.g. someone called document.adoptNode(el)).
@@ -603,8 +591,7 @@ class CustomElement extends HTMLElement {
      * @return {void}
      * @since 1.7.0
      */
-    adoptedCallback() {
-    }
+    adoptedCallback() {}
 
     /**
      * Called when an observed attribute has been added, removed, updated, or replaced. Also called for initial
@@ -621,7 +608,7 @@ class CustomElement extends HTMLElement {
         const self = this;
 
         if (attrName.startsWith("data-monster-option-")) {
-            setOptionFromAttribute(self, attrName, this[internalSymbol].getSubject()["options"])
+            setOptionFromAttribute(self, attrName, this[internalSymbol].getSubject()["options"]);
         }
 
         const callback = self[attributeObserverSymbol]?.[attrName];
@@ -631,7 +618,6 @@ class CustomElement extends HTMLElement {
             } catch (e) {
                 addAttributeToken(self, ATTRIBUTE_ERRORMESSAGE, e.toString());
             }
-
         }
     }
 
@@ -658,7 +644,7 @@ class CustomElement extends HTMLElement {
 
     /**
      * Calls a callback function if it exists.
-     * 
+     *
      * @param {string} name
      * @param {*} args
      * @returns {*}
@@ -667,8 +653,6 @@ class CustomElement extends HTMLElement {
         const self = this;
         return callControlCallback.call(self, name, ...args);
     }
-
-
 }
 
 /**
@@ -685,7 +669,6 @@ function callControlCallback(callBackFunctionName, ...args) {
 
     if (callBackFunctionName in self) {
         return self[callBackFunctionName](self, ...args);
-        
     }
 
     if (!self.hasAttribute(ATTRIBUTE_SCRIPT_HOST)) {
@@ -693,13 +676,12 @@ function callControlCallback(callBackFunctionName, ...args) {
     }
 
     if (self[scriptHostElementSymbol].length === 0) {
-
         const targetId = self.getAttribute(ATTRIBUTE_SCRIPT_HOST);
         if (!targetId) {
             return;
         }
 
-        const list = targetId.split(",")
+        const list = targetId.split(",");
         for (const id of list) {
             const host = findElementWithIdUpwards(self, targetId);
             if (!(host instanceof HTMLElement)) {
@@ -721,33 +703,34 @@ function callControlCallback(callBackFunctionName, ...args) {
     }
 
     addAttributeToken(self, ATTRIBUTE_ERRORMESSAGE, `callback ${callBackFunctionName} not found`);
-
 }
 
 /**
- * This Function is called when the element is attached to the DOM.
- *
- * It looks for the attribute `data-monster-option-callback`. Is this attribute is not set, the default callback
- * `initCustomControlCallback` is called.
- *
- * The callback is searched in this element and in the host element. If the callback is found, it is called with the
- * element as parameter.
+ * Initializes the custom element based on the provided callback function.
  *
- * The `monster
+ * This function is called when the element is attached to the DOM. It checks if the
+ * `data-monster-option-callback` attribute is set, and if not, the default callback
+ * `initCustomControlCallback` is called. The callback function is searched for in this
+ * element and in the host element. If the callback is found, it is called with the element
+ * as a parameter.
  *
  * @this CustomElement
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/CustomElementRegistry/define#providing_a_construction_callback
+ * @since 1.8.0
  */
 function initFromCallbackHost() {
     const self = this;
 
-    let callBackFunctionName = initControlCallbackName // default callback
-    if (self.hasAttribute(ATTRIBUTE_OPTION_CALLBACK)) {
-        callBackFunctionName = self.getAttribute(ATTRIBUTE_OPTION_CALLBACK);
+    // Set the default callback function name
+    let callBackFunctionName = initControlCallbackName;
+
+    // If the `data-monster-option-callback` attribute is set, use its value as the callback function name
+    if (self.hasAttribute(ATTRIBUTE_INIT_CALLBACK)) {
+        callBackFunctionName = self.getAttribute(ATTRIBUTE_INIT_CALLBACK);
     }
 
+    // Call the callback function with the element as a parameter if it exists
     callControlCallback.call(self, callBackFunctionName);
-
-
 }
 
 /**
@@ -766,7 +749,11 @@ function attachAttributeChangeMutationObserver() {
     self[attributeMutationObserverSymbol] = new MutationObserver(function (mutations, observer) {
         for (const mutation of mutations) {
             if (mutation.type === "attributes") {
-                self.attributeChangedCallback(mutation.attributeName, mutation.oldValue, mutation.target.getAttribute(mutation.attributeName));
+                self.attributeChangedCallback(
+                    mutation.attributeName,
+                    mutation.oldValue,
+                    mutation.target.getAttribute(mutation.attributeName),
+                );
             }
         }
     });
@@ -776,7 +763,6 @@ function attachAttributeChangeMutationObserver() {
             attributes: true,
             attributeOldValue: true,
         });
-
     } catch (e) {
         addAttributeToken(self, ATTRIBUTE_ERRORMESSAGE, e.toString());
     }
@@ -974,8 +960,7 @@ function parseOptionsJSON(data) {
     try {
         let dataUrl = parseDataURL(data);
         data = dataUrl.content;
-    } catch (e) {
-    }
+    } catch (e) {}
 
     try {
         obj = JSON.parse(data);

package/source/dom/dimension.mjs

@@ -75,10 +75,8 @@ function getDeviceDPI() {
  */
 
 function convertToPixels(value, parentElement = document.documentElement, fontSizeElement = document.documentElement) {
-    
     validateString(value);
-    
-    
+
     const regex = /^(-?[\d.]+)(.*)$/;
     const matchResult = value.match(regex);
 

package/source/dom/util/extract-keys.mjs

@@ -5,7 +5,7 @@
  * License text available at https://www.gnu.org/licenses/agpl-3.0.en.html
  */
 
-export {extractKeys}
+export { extractKeys };
 
 /**
  * Extracts the keys from the given object and returns a map with the keys and values.
@@ -17,17 +17,21 @@ export {extractKeys}
  * @param {string} valueSeparator
  * @returns {Map<any, any>}
  */
-function extractKeys(obj, keyPrefix = '', keySeparator = '-', valueSeparator = '.') {
+function extractKeys(obj, keyPrefix = "", keySeparator = "-", valueSeparator = ".") {
     const resultMap = new Map();
 
     function helper(currentObj, currentKeyPrefix, currentValuePrefix) {
         for (const key in currentObj) {
-            if (typeof currentObj[key] === 'object' && !Array.isArray(currentObj[key])) {
-                const newKeyPrefix = currentKeyPrefix ? currentKeyPrefix + keySeparator + key.toLowerCase() : key.toLowerCase();
+            if (typeof currentObj[key] === "object" && !Array.isArray(currentObj[key])) {
+                const newKeyPrefix = currentKeyPrefix
+                    ? currentKeyPrefix + keySeparator + key.toLowerCase()
+                    : key.toLowerCase();
                 const newValuePrefix = currentValuePrefix ? currentValuePrefix + valueSeparator + key : key;
                 helper(currentObj[key], newKeyPrefix, newValuePrefix);
             } else {
-                const finalKey = currentKeyPrefix ? currentKeyPrefix + keySeparator + key.toLowerCase() : key.toLowerCase();
+                const finalKey = currentKeyPrefix
+                    ? currentKeyPrefix + keySeparator + key.toLowerCase()
+                    : key.toLowerCase();
                 const finalValue = currentValuePrefix ? currentValuePrefix + valueSeparator + key : key;
                 resultMap.set(finalKey, finalValue);
             }
@@ -36,4 +40,4 @@ function extractKeys(obj, keyPrefix = '', keySeparator = '-', valueSeparator = '
 
     helper(obj, keyPrefix, keyPrefix);
     return resultMap;
-}
+}