@schukai/monster 3.74.0 → 3.76.0

package/source/components/layout/collapse.mjs

@@ -13,22 +13,22 @@
  */
 
 import {
-	assembleMethodSymbol,
-	CustomElement,
-	getSlottedElements,
-	registerCustomElement,
+    assembleMethodSymbol,
+    CustomElement,
+    getSlottedElements,
+    registerCustomElement,
 } from "../../dom/customelement.mjs";
-import { CollapseStyleSheet } from "./stylesheet/collapse.mjs";
-import { fireCustomEvent } from "../../dom/events.mjs";
-import { getDocument } from "../../dom/util.mjs";
-import { addAttributeToken } from "../../dom/attributes.mjs";
-import { ATTRIBUTE_ERRORMESSAGE } from "../../dom/constants.mjs";
-import { Host } from "../host/host.mjs";
-import { generateUniqueConfigKey } from "../host/util.mjs";
-import { DeadMansSwitch } from "../../util/deadmansswitch.mjs";
-import { instanceSymbol } from "../../constants.mjs";
-
-export { Collapse, nameSymbol };
+import {CollapseStyleSheet} from "./stylesheet/collapse.mjs";
+import {fireCustomEvent} from "../../dom/events.mjs";
+import {getDocument} from "../../dom/util.mjs";
+import {addAttributeToken} from "../../dom/attributes.mjs";
+import {ATTRIBUTE_ERRORMESSAGE} from "../../dom/constants.mjs";
+import {Host} from "../host/host.mjs";
+import {generateUniqueConfigKey} from "../host/util.mjs";
+import {DeadMansSwitch} from "../../util/deadmansswitch.mjs";
+import {instanceSymbol} from "../../constants.mjs";
+
+export {Collapse, nameSymbol};
 
 /**
  * @private
@@ -80,330 +80,296 @@ const detailsDecoElementSymbol = Symbol("detailsDecoElement");
 const nameSymbol = Symbol("name");
 
 /**
- * The Collapse component is used to show the details.
+ * A Collapse component
  *
- * <img src="./images/collapse.png">
+ * @fragments /fragments/components/layout/collapse/
  *
- * Dependencies: the system uses functions of the [monsterjs](https://monsterjs.org/) library
- *
- * You can create this control either by specifying the HTML tag <monster-collapse />` directly in the HTML or using
- * Javascript via the `document.createElement('monster-collapse');` method.
- *
- * ```html
- * <monster-collapse></monster-collapse>
- * ```
- *
- * Or you can create this CustomControl directly in Javascript:
- *
- * ```js
- * import '@schukai/monster/source/components/host/collapse.mjs';
- * document.createElement('monster-collapse');
- * ```
- *
- * The Body should have a class "hidden" to ensure that the styles are applied correctly.
- *
- * ```css
- * body.hidden {
- *    visibility: hidden;
- * }
- * ```
- *
- * @startuml collapse.png
- * skinparam monochrome true
- * skinparam shadowing false
- * HTMLElement <|-- CustomElement
- * CustomElement <|-- Collapse
- * @enduml
+ * @example /examples/components/layout/collapse-simple
  *
+ * @since 3.74.0
  * @copyright schukai GmbH
- * @memberOf Monster.Components.Host
- * @summary A simple collapse component
- * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-open
- * @fires Monster.Components.Host.Collapse.event:monster-collapse-open
- * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-close
- * @fires Monster.Components.Host.Collapse.event:monster-collapse-closed
- * @fires Monster.Components.Host.Collapse.event:monster-collapse-adjust-height
+ * @summary  A simple collapse component.
  */
 class Collapse extends CustomElement {
-	/**
-	 * This method is called by the `instanceof` operator.
-	 * @returns {symbol}
-	 */
-	static get [instanceSymbol]() {
-		return Symbol.for("@schukai/monster/components/layout/collapse@@instance");
-	}
-
-	/**
-	 *
-	 */
-	constructor() {
-		super();
-		// the name is only used for the host config and the event name
-		this[nameSymbol] = "collapse";
-	}
-
-	/**
-	 * To set the options via the html tag the attribute `data-monster-options` must be used.
-	 * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
-	 *
-	 * The individual configuration values can be found in the table.
-	 *
-	 * @property {Object} templates Template definitions
-	 * @property {string} templates.main Main template
-	 * @property {Object} classes CSS classes
-	 * @property {string} classes.container CSS class for the container
-	 * @property {Object} features Feature configuration
-	 * @property {boolean} features.accordion Enable accordion mode
-	 * @property {boolean} features.persistState Enable persist state (Host and Config-Manager required)
-	 * @property {boolean} features.useScrollValues Use scroll values (scrollHeight) instead of clientHeight for the height calculation
-	 * @property {boolean} openByDefault Open the details by default
-	 */
-	get defaults() {
-		return Object.assign({}, super.defaults, {
-			templates: {
-				main: getTemplate(),
-			},
-			classes: {
-				container: "padding",
-			},
-			features: {
-				accordion: true,
-				persistState: true,
-				useScrollValues: false,
-			},
-			openByDefault: false,
-		});
-	}
-
-	/**
-	 *
-	 * @returns {Monster.Components.Host.Collapse}
-	 */
-	[assembleMethodSymbol]() {
-		super[assembleMethodSymbol]();
-		initControlReferences.call(this);
-		initStateFromHostConfig.call(this);
-		initResizeObserver.call(this);
-		initEventHandler.call(this);
-
-		if (this.getOption("openByDefault")) {
-			this.open();
-		}
-	}
-
-	/**
-	 *
-	 */
-	connectedCallback() {
-		super.connectedCallback();
-		updateResizeObserverObservation.call(this);
-		//  this[resizeObserverSymbol].observe(getDocument().body);
-	}
-
-	/**
-	 *
-	 */
-	disconnectedCallback() {
-		super.disconnectedCallback();
-		//this[resizeObserverSymbol].disconnect();
-	}
-
-	/**
-	 *
-	 * @returns {Monster.Components.Host.Collapse}
-	 */
-	toggle() {
-		if (this[detailsElementSymbol].classList.contains("active")) {
-			this.close();
-		} else {
-			this.open();
-		}
-		return this;
-	}
-
-	/**
-	 *
-	 * @returns {boolean}
-	 */
-	isClosed() {
-		return !this[detailsElementSymbol].classList.contains("active");
-	}
-
-	/**
-	 *
-	 * @returns {boolean}
-	 */
-	isOpen() {
-		return !this.isClosed();
-	}
-
-	/**
-	 *
-	 * @returns {Monster.Components.Host.Collapse}
-	 * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-open
-	 * @fires Monster.Components.Host.Collapse.event:monster-collapse-open
-	 */
-	open() {
-		let node;
-		if (this[detailsElementSymbol].classList.contains("active")) {
-			return this;
-		}
-
-		fireCustomEvent(this, "monster-" + this[nameSymbol] + "-before-open", {});
-
-		adjustHeight.call(this);
-		this[detailsElementSymbol].classList.add("active");
-
-		if (this.getOption("features.accordion") === true) {
-			node = this;
-			while (node.nextElementSibling instanceof Collapse) {
-				node = node.nextElementSibling;
-				node.close();
-			}
-
-			node = this;
-			while (node.previousElementSibling instanceof Collapse) {
-				node = node.previousElementSibling;
-				node.close();
-			}
-		}
-
-		setTimeout(() => {
-			setTimeout(() => {
-				updateStateConfig.call(this);
-				fireCustomEvent(this, "monster-" + this[nameSymbol] + "-open", {});
-				setTimeout(() => {
-					this[controlElementSymbol].classList.remove("overflow-hidden");
-				}, 500);
-			}, 0);
-		}, 0);
-
-		return this;
-	}
-
-	/**
-	 *
-	 * @returns {Monster.Components.Host.Collapse}
-	 * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-close
-	 * @fires Monster.Components.Host.Collapse.event:monster-collapse-closed
-	 */
-	close() {
-		if (!this[detailsElementSymbol].classList.contains("active")) {
-			return this;
-		}
-
-		fireCustomEvent(this, "monster-" + this[nameSymbol] + "-before-close", {});
-		this[controlElementSymbol].classList.add("overflow-hidden");
-
-		setTimeout(() => {
-			this[detailsElementSymbol].classList.remove("active");
-			setTimeout(() => {
-				updateStateConfig.call(this);
-				fireCustomEvent(this, "monster-" + this[nameSymbol] + "-closed", {});
-			}, 0);
-		}, 0);
-
-		return this;
-	}
-
-	/**
-	 *
-	 * @return {string}
-	 */
-	static getTag() {
-		return "monster-collapse";
-	}
-
-	/**
-	 * @return {Array<CSSStyleSheet>}
-	 */
-	static getCSSStyleSheet() {
-		return [CollapseStyleSheet];
-	}
-
-	/**
-	 * This method is called when the element is inserted into a document, including into a shadow tree.
-	 * @return {Monster.Components.Host.Collapse}
-	 * @fires Monster.Components.Host.Collapse.event:monster-collapse-adjust-height
-	 */
-	adjustHeight() {
-		adjustHeight.call(this);
-		return this;
-	}
+    /**
+     * This method is called by the `instanceof` operator.
+     * @returns {symbol}
+     */
+    static get [instanceSymbol]() {
+        return Symbol.for("@schukai/monster/components/layout/collapse@@instance");
+    }
+
+    /**
+     *
+     */
+    constructor() {
+        super();
+        // the name is only used for the host config and the event name
+        this[nameSymbol] = "collapse";
+    }
+
+    /**
+     * To set the options via the html tag the attribute `data-monster-options` must be used.
+     * @see {@link https://monsterjs.org/en/doc/#configurate-a-monster-control}
+     *
+     * The individual configuration values can be found in the table.
+     *
+     * @property {Object} templates Template definitions
+     * @property {string} templates.main Main template
+     * @property {Object} classes CSS classes
+     * @property {string} classes.container CSS class for the container
+     * @property {Object} features Feature configuration
+     * @property {boolean} features.accordion Enable accordion mode
+     * @property {boolean} features.persistState Enable persist state (Host and Config-Manager required)
+     * @property {boolean} features.useScrollValues Use scroll values (scrollHeight) instead of clientHeight for the height calculation
+     * @property {boolean} openByDefault Open the details by default
+     */
+    get defaults() {
+        return Object.assign({}, super.defaults, {
+            templates: {
+                main: getTemplate(),
+            },
+            classes: {
+                container: "padding",
+            },
+            features: {
+                accordion: true,
+                persistState: true,
+                useScrollValues: false,
+            },
+            openByDefault: false,
+        });
+    }
+
+    /**
+     *
+     * @returns {Monster.Components.Host.Collapse}
+     */
+    [assembleMethodSymbol]() {
+        super[assembleMethodSymbol]();
+        initControlReferences.call(this);
+        initStateFromHostConfig.call(this);
+        initResizeObserver.call(this);
+        initEventHandler.call(this);
+
+        if (this.getOption("openByDefault")) {
+            this.open();
+        }
+    }
+
+    /**
+     *
+     */
+    connectedCallback() {
+        super.connectedCallback();
+        updateResizeObserverObservation.call(this);
+        //  this[resizeObserverSymbol].observe(getDocument().body);
+    }
+
+    /**
+     *
+     */
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        //this[resizeObserverSymbol].disconnect();
+    }
+
+    /**
+     *
+     * @returns {Monster.Components.Host.Collapse}
+     */
+    toggle() {
+        if (this[detailsElementSymbol].classList.contains("active")) {
+            this.close();
+        } else {
+            this.open();
+        }
+        return this;
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    isClosed() {
+        return !this[detailsElementSymbol].classList.contains("active");
+    }
+
+    /**
+     *
+     * @returns {boolean}
+     */
+    isOpen() {
+        return !this.isClosed();
+    }
+
+    /**
+     *
+     * @returns {Monster.Components.Host.Collapse}
+     * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-open
+     * @fires Monster.Components.Host.Collapse.event:monster-collapse-open
+     */
+    open() {
+        let node;
+        if (this[detailsElementSymbol].classList.contains("active")) {
+            return this;
+        }
+
+        fireCustomEvent(this, "monster-" + this[nameSymbol] + "-before-open", {});
+
+        adjustHeight.call(this);
+        this[detailsElementSymbol].classList.add("active");
+
+        if (this.getOption("features.accordion") === true) {
+            node = this;
+            while (node.nextElementSibling instanceof Collapse) {
+                node = node.nextElementSibling;
+                node.close();
+            }
+
+            node = this;
+            while (node.previousElementSibling instanceof Collapse) {
+                node = node.previousElementSibling;
+                node.close();
+            }
+        }
+
+        setTimeout(() => {
+            setTimeout(() => {
+                updateStateConfig.call(this);
+                fireCustomEvent(this, "monster-" + this[nameSymbol] + "-open", {});
+                setTimeout(() => {
+                    this[controlElementSymbol].classList.remove("overflow-hidden");
+                }, 500);
+            }, 0);
+        }, 0);
+
+        return this;
+    }
+
+    /**
+     *
+     * @returns {Monster.Components.Host.Collapse}
+     * @fires Monster.Components.Host.Collapse.event:monster-collapse-before-close
+     * @fires Monster.Components.Host.Collapse.event:monster-collapse-closed
+     */
+    close() {
+        if (!this[detailsElementSymbol].classList.contains("active")) {
+            return this;
+        }
+
+        fireCustomEvent(this, "monster-" + this[nameSymbol] + "-before-close", {});
+        this[controlElementSymbol].classList.add("overflow-hidden");
+
+        setTimeout(() => {
+            this[detailsElementSymbol].classList.remove("active");
+            setTimeout(() => {
+                updateStateConfig.call(this);
+                fireCustomEvent(this, "monster-" + this[nameSymbol] + "-closed", {});
+            }, 0);
+        }, 0);
+
+        return this;
+    }
+
+    /**
+     *
+     * @return {string}
+     */
+    static getTag() {
+        return "monster-collapse";
+    }
+
+    /**
+     * @return {Array<CSSStyleSheet>}
+     */
+    static getCSSStyleSheet() {
+        return [CollapseStyleSheet];
+    }
+
+    /**
+     * This method is called when the element is inserted into a document, including into a shadow tree.
+     * @return {Monster.Components.Host.Collapse}
+     * @fires Monster.Components.Host.Collapse.event:monster-collapse-adjust-height
+     */
+    adjustHeight() {
+        adjustHeight.call(this);
+        return this;
+    }
 }
 
 function adjustHeight() {
-	let height = 0;
-
-	if (this[detailsContainerElementSymbol]) {
-		if (this.getOption("features.useScrollValues")) {
-			height += this[detailsContainerElementSymbol].scrollHeight;
-		} else {
-			height += this[detailsContainerElementSymbol].clientHeight;
-		}
-	}
-
-	if (this[detailsDecoElementSymbol]) {
-		if (this.getOption("features.useScrollValues")) {
-			height += this[detailsDecoElementSymbol].scrollHeight;
-		} else {
-			height += this[detailsDecoElementSymbol].clientHeight + 1;
-		}
-	}
-
-	if (height === 0) {
-		if (this.getOption("features.useScrollValues")) {
-			height = this[detailsElementSymbol].scrollHeight;
-		} else {
-			height = this[detailsElementSymbol].clientHeight;
-		}
-
-		if (height === 0) {
-			height = "auto";
-		}
-	} else {
-		height += "px";
-	}
-
-	this[detailsElementSymbol].style.setProperty(
-		"--monster-height",
-		height,
-		"important",
-	);
-	fireCustomEvent(this, "monster-" + this[nameSymbol] + "-adjust-height", {});
+    let height = 0;
+
+    if (this[detailsContainerElementSymbol]) {
+        if (this.getOption("features.useScrollValues")) {
+            height += this[detailsContainerElementSymbol].scrollHeight;
+        } else {
+            height += this[detailsContainerElementSymbol].clientHeight;
+        }
+    }
+
+    if (this[detailsDecoElementSymbol]) {
+        if (this.getOption("features.useScrollValues")) {
+            height += this[detailsDecoElementSymbol].scrollHeight;
+        } else {
+            height += this[detailsDecoElementSymbol].clientHeight + 1;
+        }
+    }
+
+    if (height === 0) {
+        if (this.getOption("features.useScrollValues")) {
+            height = this[detailsElementSymbol].scrollHeight;
+        } else {
+            height = this[detailsElementSymbol].clientHeight;
+        }
+
+        if (height === 0) {
+            height = "auto";
+        }
+    } else {
+        height += "px";
+    }
+
+    this[detailsElementSymbol].style.setProperty(
+        "--monster-height",
+        height,
+        "important",
+    );
+    fireCustomEvent(this, "monster-" + this[nameSymbol] + "-adjust-height", {});
 }
 
 function updateResizeObserverObservation() {
-	this[resizeObserverSymbol].disconnect();
+    this[resizeObserverSymbol].disconnect();
 
-	const slottedNodes = getSlottedElements.call(this);
-	slottedNodes.forEach((node) => {
-		this[resizeObserverSymbol].observe(node);
-	});
+    const slottedNodes = getSlottedElements.call(this);
+    slottedNodes.forEach((node) => {
+        this[resizeObserverSymbol].observe(node);
+    });
 
-	if (this[detailsContainerElementSymbol]) {
-		this[resizeObserverSymbol].observe(this[detailsContainerElementSymbol]);
-	}
+    if (this[detailsContainerElementSymbol]) {
+        this[resizeObserverSymbol].observe(this[detailsContainerElementSymbol]);
+    }
 
-	this.adjustHeight();
+    this.adjustHeight();
 }
 
 /**
  * @private
  */
 function initEventHandler() {
-	if (!this.shadowRoot) {
-		throw new Error("no shadow-root is defined");
-	}
+    if (!this.shadowRoot) {
+        throw new Error("no shadow-root is defined");
+    }
 
-	initSlotChangedHandler.call(this);
-	return this;
+    initSlotChangedHandler.call(this);
+    return this;
 }
 
 function initSlotChangedHandler() {
-	this[detailsSlotElementSymbol].addEventListener("slotchange", () => {
-		updateResizeObserverObservation.call(this);
-	});
+    this[detailsSlotElementSymbol].addEventListener("slotchange", () => {
+        updateResizeObserverObservation.call(this);
+    });
 }
 
 /**
@@ -412,23 +378,23 @@ function initSlotChangedHandler() {
  * @throws {Error} no shadow-root is defined
  */
 function initControlReferences() {
-	if (!this.shadowRoot) {
-		throw new Error("no shadow-root is defined");
-	}
-
-	this[controlElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=control]",
-	);
-	this[detailsElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=detail]",
-	);
-	this[detailsSlotElementSymbol] = this.shadowRoot.querySelector("slot");
-	this[detailsContainerElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=container]",
-	);
-	this[detailsDecoElementSymbol] = this.shadowRoot.querySelector(
-		"[data-monster-role=deco]",
-	);
+    if (!this.shadowRoot) {
+        throw new Error("no shadow-root is defined");
+    }
+
+    this[controlElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=control]",
+    );
+    this[detailsElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=detail]",
+    );
+    this[detailsSlotElementSymbol] = this.shadowRoot.querySelector("slot");
+    this[detailsContainerElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=container]",
+    );
+    this[detailsDecoElementSymbol] = this.shadowRoot.querySelector(
+        "[data-monster-role=deco]",
+    );
 }
 
 /**
@@ -436,34 +402,34 @@ function initControlReferences() {
  * @returns {string}
  */
 function getConfigKey() {
-	return generateUniqueConfigKey(this[nameSymbol], this.id, "state");
+    return generateUniqueConfigKey(this[nameSymbol], this.id, "state");
 }
 
 /**
  * @private
  */
 function updateStateConfig() {
-	if (!this.getOption("features.persistState")) {
-		return;
-	}
-
-	if (!this[detailsElementSymbol]) {
-		return;
-	}
-
-	const document = getDocument();
-	const host = document.querySelector("monster-host");
-	if (!(host && this.id)) {
-		return;
-	}
-
-	const configKey = getConfigKey.call(this);
-
-	try {
-		host.setConfig(configKey, this.isOpen());
-	} catch (error) {
-		addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, String(error));
-	}
+    if (!this.getOption("features.persistState")) {
+        return;
+    }
+
+    if (!this[detailsElementSymbol]) {
+        return;
+    }
+
+    const document = getDocument();
+    const host = document.querySelector("monster-host");
+    if (!(host && this.id)) {
+        return;
+    }
+
+    const configKey = getConfigKey.call(this);
+
+    try {
+        host.setConfig(configKey, this.isOpen());
+    } catch (error) {
+        addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, String(error));
+    }
 }
 
 /**
@@ -471,55 +437,55 @@ function updateStateConfig() {
  * @returns {Promise}
  */
 function initStateFromHostConfig() {
-	if (!this.getOption("features.persistState")) {
-		return Promise.resolve({});
-	}
-
-	const document = getDocument();
-	const host = document.querySelector("monster-host");
-
-	if (!(host && this.id)) {
-		return Promise.resolve({});
-	}
-
-	const configKey = getConfigKey.call(this);
-	return host
-		.getConfig(configKey)
-		.then((state) => {
-			if (state === true) {
-				this.open();
-			} else {
-				this.close();
-			}
-		})
-		.catch((error) => {
-			addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, error.toString());
-		});
+    if (!this.getOption("features.persistState")) {
+        return Promise.resolve({});
+    }
+
+    const document = getDocument();
+    const host = document.querySelector("monster-host");
+
+    if (!(host && this.id)) {
+        return Promise.resolve({});
+    }
+
+    const configKey = getConfigKey.call(this);
+    return host
+        .getConfig(configKey)
+        .then((state) => {
+            if (state === true) {
+                this.open();
+            } else {
+                this.close();
+            }
+        })
+        .catch((error) => {
+            addAttributeToken(this, ATTRIBUTE_ERRORMESSAGE, error.toString());
+        });
 }
 
 /**
  * @private
  */
 function initResizeObserver() {
-	// against flickering
-	this[resizeObserverSymbol] = new ResizeObserver((entries) => {
-		if (this[timerCallbackSymbol] instanceof DeadMansSwitch) {
-			try {
-				this[timerCallbackSymbol].touch();
-				return;
-			} catch (e) {
-				delete this[timerCallbackSymbol];
-			}
-		}
-
-		this[timerCallbackSymbol] = new DeadMansSwitch(200, () => {
-			checkAndRearrangeContent.call(this);
-		});
-	});
+    // against flickering
+    this[resizeObserverSymbol] = new ResizeObserver((entries) => {
+        if (this[timerCallbackSymbol] instanceof DeadMansSwitch) {
+            try {
+                this[timerCallbackSymbol].touch();
+                return;
+            } catch (e) {
+                delete this[timerCallbackSymbol];
+            }
+        }
+
+        this[timerCallbackSymbol] = new DeadMansSwitch(200, () => {
+            checkAndRearrangeContent.call(this);
+        });
+    });
 }
 
 function checkAndRearrangeContent() {
-	this.adjustHeight();
+    this.adjustHeight();
 }
 
 /**
@@ -527,8 +493,8 @@ function checkAndRearrangeContent() {
  * @return {string}
  */
 function getTemplate() {
-	// language=HTML
-	return `
+    // language=HTML
+    return `
         <div data-monster-role="control" part="control" class="overflow-hidden">
             <div data-monster-role="detail">
                 <div data-monster-attributes="class path:classes.container" part="container"