@schukai/monster 3.74.0 → 3.76.0

package/source/components/layout/details.mjs

@@ -38,49 +38,15 @@ const buttonElementSymbol = Symbol("buttonElement");
 const buttonEventHandlerSymbol = Symbol("buttonEventHandler");
 
 /**
- * The Details component is used to show a details.
+ * A Details component
  *
- * <img src="./images/details.png">
+ * @fragments /fragments/components/layout/details/
  *
- * Dependencies: the system uses functions of the [monsterjs](https://monsterjs.org/) library
- *
- * You can create this control either by specifying the HTML tag <monster-details />` directly in the HTML or using
- * Javascript via the `document.createElement('monster-details');` method.
- *
- * ```html
- * <monster-details></monster-details>
- * ```
- *
- * Or you can create this CustomControl directly in Javascript:
- *
- * ```js
- * import '@schukai/component-state/source/details.mjs';
- * document.createElement('monster-details');
- * ```
- *
- * The Body should have a class "hidden" to ensure that the styles are applied correctly.
- *
- * ```css
- * body.hidden {
- *    visibility: hidden;
- * }
- * ```
- *
- * @startuml details.png
- * skinparam monochrome true
- * skinparam shadowing false
- * HTMLElement <|-- CustomElement
- * CustomElement <|-- Collapse
- * Collapse <|-- Details
- * @enduml
+ * @example /examples/components/layout/details-simple
  *
+ * @since 3.74.0
  * @copyright schukai GmbH
- * @memberOf Monster.Components.Layout
- * @summary A simple details component
- * @fires Monster.Components.Layout.Details.event:monster-details-before-open
- * @fires Monster.Components.Layout.Details.event:monster-details-open
- * @fires Monster.Components.Layout.Details.event:monster-details-before-close
- * @fires Monster.Components.Layout.Details.event:monster-details-closed
+ * @summary A simple but cool Details component
  */
 class Details extends Collapse {
 	/**
@@ -215,13 +181,17 @@ function initButtonLabel() {
 	if (this.hasAttribute(ATTRIBUTE_BUTTON_LABEL)) {
 		label = this.getAttribute(ATTRIBUTE_BUTTON_LABEL);
 	} else {
-		label = this.innerText;
+		label = this.getOption("labels.button", "Details");
 	}
 
 	if (!isString(label)) {
 		label = "";
 	}
 
+	if (label==="") {
+		label = this.innerText;
+	}
+
 	label = label.trim();
 
 	if (label === "") {

package/source/components/layout/iframe.mjs

@@ -0,0 +1,358 @@
+/**
+ * Copyright © schukai GmbH and all contributing authors, {{copyRightYear}}. All rights reserved.
+ * Node module: @schukai/monster
+ *
+ * This source code is licensed under the GNU Affero General Public License version 3 (AGPLv3).
+ * The full text of the license can be found at: https://www.gnu.org/licenses/agpl-3.0.en.html
+ *
+ * For those who do not wish to adhere to the AGPLv3, a commercial license is available.
+ * Acquiring a commercial license allows you to use this software without complying with the AGPLv3 terms.
+ * For more information about purchasing a commercial license, please contact schukai GmbH.
+ */
+
+import { instanceSymbol } from "../../constants.mjs";
+import { addAttributeToken } from "../../dom/attributes.mjs";
+import {
+	ATTRIBUTE_ERRORMESSAGE,
+	ATTRIBUTE_ROLE,
+} from "../../dom/constants.mjs";
+import { CustomControl } from "../../dom/customcontrol.mjs";
+import { CustomElement } from "../../dom/customelement.mjs";
+import {
+	assembleMethodSymbol,
+	registerCustomElement,
+} from "../../dom/customelement.mjs";
+import { findTargetElementFromEvent } from "../../dom/events.mjs";
+import { isFunction } from "../../types/is.mjs";
+import { DeadMansSwitch } from "../../util/deadmansswitch.mjs";
+import { IframeStyleSheet } from "./stylesheet/iframe.mjs";
+import { fireCustomEvent } from "../../dom/events.mjs";
+
+export { Iframe };
+
+/**
+ * @private
+ * @type {symbol}
+ */
+export const iframeElementSymbol = Symbol("iframeElement");
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const PanelElementSymbol = Symbol("PanelElement");
+
+/**
+ * local symbol
+ * @private
+ * @type {symbol}
+ */
+const resizeObserverSymbol = Symbol("resizeObserver");
+
+/**
+ * @private
+ * @type {symbol}
+ */
+const timerCallbackSymbol = Symbol("timerCallback");
+
+/**
+ * A Iframe Control
+ *
+ * @fragments /fragments/components/layout/iframe/
+ *
+ * @example /examples/components/layout/iframe-simple
+ * 
+ * @since 3.76.0
+ * @copyright schukai GmbH
+ * @summary A cool and fancy Iframe that can make your life easier and also looks good.
+ */
+class Iframe extends CustomElement {
+	/**
+	 * This method is called by the `instanceof` operator.
+	 * @returns {symbol}
+	 */
+	static get [instanceSymbol]() {
+		return Symbol.for("@schukai/monster/components/layout/iframe@@instance");
+	}
+
+	/**
+	 *
+	 * @return {Components.Layout.Iframe
+	 */
+	[assembleMethodSymbol]() {
+		super[assembleMethodSymbol]();
+		initControlReferences.call(this);
+		initEventHandler.call(this);
+		calcHeight.call(this);
+		return this;
+	}
+
+	/**
+	 * This method is called by the dom and should not be called directly.
+	 *
+	 * @return {void}
+	 */
+	connectedCallback() {
+		super.connectedCallback();
+		attachResizeObserver.call(this);
+
+		// disable scrolling in parent node
+		if (this.parentNode && this.parentNode instanceof HTMLElement) {
+			this.parentNode.style.overflow = "hidden";
+		}
+	}
+
+	/**
+	 * This method is called by the dom and should not be called directly.
+	 *
+	 * @return {void}
+	 */
+	disconnectedCallback() {
+		super.disconnectedCallback();
+		disconnectResizeObserver.call(this);
+	}
+
+	/**
+	 * 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} labels Label definitions
+	 * @property {Object} actions Callbacks
+	 * @property {string} actions.click="throw Error" Callback when clicked
+	 * @property {Object} features Features
+	 * @property {Object} classes CSS classes
+	 * @property {boolean} disabled=false Disabled state
+	 */
+	get defaults() {
+		return Object.assign({}, super.defaults, {
+			templates: {
+				main: getTemplate(),
+			},
+			src: null,
+
+			/* "allow-forms allow-pointer-lock allow-popups allow-same-origin allow-scripts allow-top-navigation"*/
+			sandbox: null,
+
+			labels: {},
+			classes: {},
+
+			name: "",
+
+			referrerpolicy: "no-referrer",
+
+			disabled: false,
+			features: {
+				allowfullscreen: true,
+				allowpaymentrequest: true,
+				loading: "egager",
+			},
+			actions: {
+				click: () => {
+					throw new Error("the click action is not defined");
+				},
+			},
+		});
+	}
+
+	/**
+	 * @return {string}
+	 */
+	static getTag() {
+		return "monster-iframe";
+	}
+
+	/**
+	 * @return {CSSStyleSheet[]}
+	 */
+	static getCSSStyleSheet() {
+		return [IframeStyleSheet];
+	}
+}
+
+/**
+ * @private
+ */
+function calcHeight() {
+	this.style.boxSizing = "border-box";
+
+	const height = calculateMaximumHeight.call(this, this.parentNode);
+	console.log("height", height);
+	if (height < 0 || isNaN(height)) {
+		return;
+	}
+
+	this[iframeElementSymbol].style.height = `${height}px`;
+}
+
+/**
+ * Calculate the maximum height of an element based on the window's inner height
+ * @param element
+ * @returns {*}
+ */
+function calculateMaximumHeight(element) {
+	let totalBottomBorder = 0;
+	let totalBottomPadding = 0;
+	let totalBottomMargin = 0;
+	let totalOutlineHeight = 0;
+	let totalBoxShadowHeight = 0;
+	let currentElement = element;
+
+	while (currentElement && currentElement !== document.body) {
+		const style = window.getComputedStyle(currentElement);
+		const boxSizing = style.boxSizing;
+
+		const elementHeight = currentElement.getBoundingClientRect().height;
+
+		const borderBottomWidth = parseFloat(style.borderBottomWidth);
+		const paddingBottom = parseFloat(style.paddingBottom);
+		const marginBottom = parseFloat(style.marginBottom);
+
+		const outlineHeight = parseFloat(style.outlineWidth);
+
+		totalBottomBorder += isNaN(borderBottomWidth) ? 0 : borderBottomWidth;
+		totalBottomPadding +=
+			isNaN(paddingBottom) || boxSizing === "border-box" ? 0 : paddingBottom;
+		totalBottomMargin += isNaN(marginBottom) ? 0 : marginBottom;
+		totalOutlineHeight += isNaN(outlineHeight) ? 0 : outlineHeight;
+
+		const boxShadow = style.boxShadow;
+		let boxShadowVerticalTotal = 0;
+
+		if (boxShadow !== "none") {
+			const boxShadowValues = boxShadow.split(" ");
+			const verticalOffset = parseFloat(boxShadowValues[3]);
+			const blurRadius = parseFloat(boxShadowValues[4]);
+			const spreadRadius = parseFloat(boxShadowValues[5]);
+
+			boxShadowVerticalTotal = verticalOffset + blurRadius + spreadRadius;
+		}
+
+		totalBoxShadowHeight += isNaN(boxShadowVerticalTotal)
+			? 0
+			: boxShadowVerticalTotal;
+
+		if (elementHeight > 200) {
+			return (
+				elementHeight -
+				totalBottomBorder -
+				totalBottomPadding -
+				totalBottomMargin -
+				totalOutlineHeight -
+				totalBoxShadowHeight
+			);
+		}
+
+		currentElement = currentElement.parentNode || currentElement.host;
+	}
+}
+
+/**
+ * @private
+ */
+function attachResizeObserver() {
+	// against flickering
+	this[resizeObserverSymbol] = new ResizeObserver(() => {
+		if (this[timerCallbackSymbol] instanceof DeadMansSwitch) {
+			try {
+				this[timerCallbackSymbol].touch();
+				return;
+			} catch (e) {
+				delete this[timerCallbackSymbol];
+			}
+		}
+
+		this[timerCallbackSymbol] = new DeadMansSwitch(200, () => {
+			calcHeight.call(this);
+		});
+	});
+
+	this[resizeObserverSymbol].observe(this.ownerDocument.body);
+	this[resizeObserverSymbol].observe(document.scrollingElement);
+}
+
+function disconnectResizeObserver() {
+	if (this[resizeObserverSymbol] instanceof ResizeObserver) {
+		this[resizeObserverSymbol].disconnect();
+	}
+}
+
+/**
+ * @private
+ * @return {initEventHandler}
+ * @fires monster-iframe-clicked
+ */
+function initEventHandler() {
+	const self = this;
+	const element = this[iframeElementSymbol];
+
+	const type = "click";
+
+	element.addEventListener(type, function (event) {
+		const callback = self.getOption("actions.click");
+
+		fireCustomEvent(self, "monster-iframe-clicked", {
+			element: self,
+		});
+
+		if (!isFunction(callback)) {
+			return;
+		}
+
+		const element = findTargetElementFromEvent(
+			event,
+			ATTRIBUTE_ROLE,
+			"control",
+		);
+
+		if (!(element instanceof Node && self.hasNode(element))) {
+			return;
+		}
+
+		callback.call(self, event);
+	});
+
+	return this;
+}
+
+/**
+ * @private
+ * @return {void}
+ */
+function initControlReferences() {
+	if (!this.shadowRoot) {
+		throw new Error("no shadow-root is defined");
+	}
+
+	this[PanelElementSymbol] = this.shadowRoot.querySelector(
+		"[data-monster-role=control]",
+	);
+
+	this[iframeElementSymbol] = this.shadowRoot.querySelector(
+		`[${ATTRIBUTE_ROLE}="control"] iframe`,
+	);
+}
+
+/**
+ * @private
+ * @return {string}
+ */
+function getTemplate() {
+	// language=HTML
+	return `
+        <div data-monster-role="control" part="control">
+			<iframe data-monster-role="iframe"
+					data-monster-attributes="sandbox path:sandbox,
+					name path:name,
+					referrerpolicy path:referrerpolicy,
+					loading path:features.loading,
+					allowpaymentrequest path:features.allowpaymentrequest,
+					allowfullscreen path:features.allowfullscreen, 
+					src path:src"
+					></iframe></div>`;
+}
+
+registerCustomElement(Iframe);

package/source/components/layout/panel.mjs

@@ -44,35 +44,15 @@ const resizeObserverSymbol = Symbol("resizeObserver");
 const timerCallbackSymbol = Symbol("timerCallback");
 
 /**
- * The Panel component is used to display a panel, isn't that cool?
+ * A Slider
  *
- * <img src="./images/panel.png">
+ * @fragments /fragments/components/layout/panel/
  *
- * You can create this control either by specifying the HTML tag <monster-panel />` directly in the HTML or using
- * Javascript via the `document.createElement('monster-panel');` method.
- *
- * ```html
- * <monster-panel></monster-panel>
- * ```
- *
- * Or you can create this CustomControl directly in Javascript:
- *
- * ```js
- * import '@schukai/monster/components/layout/panel.mjs';
- * document.createElement('monster-panel');
- * ```
- *
- * @startuml panel.png
- * skinparam monochrome true
- * skinparam shadowing false
- * HTMLElement <|-- CustomElement
- * CustomElement <|-- CustomControl
- * CustomControl <|-- Panel
- * @enduml
+ * @example /examples/components/layout/panel-simple
  *
+ * @since 3.54.0
  * @copyright schukai GmbH
- * @memberOf Monster.Components.Layout
- * @summary A simple panel component
+ * @summary The Panel component is used to display a panel, isn't that cool?
  */
 class Panel extends CustomElement {
 	/**
@@ -169,6 +149,11 @@ function calcHeight() {
 	this.style.height = `${height}px`;
 }
 
+/**
+ * Calculate the maximum height of an element based on the window's inner height
+ * @param element
+ * @returns {*}
+ */
 function calculateMaximumHeight(element) {
 	let totalBottomBorder = 0;
 	let totalBottomPadding = 0;