@zanichelli/albe-web-components 19.3.0-RC4 → 19.3.0-RC6

package/dist/cjs/utils-BY7xrW7W.js

@@ -0,0 +1,265 @@
+'use strict';
+
+var index = require('./index-wGaSHN1_.js');
+var breakpoints = require('./breakpoints-B7vFm-3T.js');
+
+/**
+ * Return boolean value for passed value if a boolean corresponding value is found
+ * Return passed value otherwise
+ */
+function boolean(value) {
+    switch (value) {
+        case true:
+        case "true":
+        case 1:
+        case "1":
+        case "on":
+        case "yes":
+            return true;
+        case false:
+        case "false":
+        case 0:
+        case "0":
+        case "off":
+        case "no":
+            return false;
+        default:
+            return value;
+    }
+}
+function randomId() {
+    return Math.random().toString(36).replace("0.", "");
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function handleKeyboardSubmit(ev, callback, ...args) {
+    if (ev.code === index.KeyboardCode.ENTER || ev.code === index.KeyboardCode.SPACE) {
+        ev.preventDefault();
+        callback(...args);
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function handleEnterKeydSubmit(ev, callback, ...args) {
+    if (ev.code === index.KeyboardCode.ENTER) {
+        ev.preventDefault();
+        callback(...args);
+    }
+}
+function getClickedElement(elem = null) {
+    if (!elem) {
+        elem = document.activeElement;
+    }
+    if (elem && elem.shadowRoot && elem.shadowRoot.activeElement) {
+        elem = elem.shadowRoot.activeElement;
+        return getClickedElement(elem);
+    }
+    return elem;
+}
+function getElementTree(elem, tree = []) {
+    tree.push(elem);
+    if (elem.parentElement) {
+        elem = elem.parentElement;
+        return getElementTree(elem, tree);
+    }
+    else if (elem.parentNode && elem.parentNode.host) {
+        elem = elem.parentNode.host;
+        return getElementTree(elem, tree);
+    }
+    return tree;
+}
+/**
+ * Get the current device type based on the window width.
+ * @returns {Device} - The current device type
+ */
+function getDevice() {
+    switch (true) {
+        case window.innerWidth <= breakpoints.Breakpoints.MOBILE:
+            return index.Device.MOBILE;
+        case window.innerWidth <= breakpoints.Breakpoints.TABLET:
+            return index.Device.TABLET;
+        case window.innerWidth <= breakpoints.Breakpoints.DESKTOP:
+            return index.Device.DESKTOP;
+        default:
+            return index.Device.DESKTOP_WIDE;
+    }
+}
+function convertJson(data) {
+    try {
+        return JSON.parse(data);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function colorFromId(id) {
+    const prefix = "avatar-C"; // prefix for color vars name
+    const colorsCount = 19; // available colors
+    const seed = Math.ceil(2 ** 31 - 1) * parseFloat(`0.${id}`);
+    let color = Math.ceil(colorsCount * (seed % 1));
+    // if result of mc is 0
+    // es.: 3895229
+    if (color === 0) {
+        color = 1;
+    }
+    return `${prefix}${color.toString().padStart(2, "0")}`;
+}
+/**
+ * Check if an element contains another element, checking both light and shadow DOM recursively.
+ * This function also checks slot assignments, so it correctly handles nested slots across components.
+ * @param ancestor Ancestor element
+ * @param descendant Descendant element
+ */
+function containsElement(ancestor, descendant) {
+    var _a;
+    if (ancestor.contains(descendant) || ((_a = ancestor.shadowRoot) === null || _a === void 0 ? void 0 : _a.contains(descendant))) {
+        return true;
+    }
+    const checkRecursive = (node) => {
+        if (node === descendant) {
+            return true;
+        }
+        const shadowRoot = node.shadowRoot;
+        if (!shadowRoot) {
+            // Check light DOM children only
+            return Array.from(node.childNodes).some(checkRecursive);
+        }
+        if (shadowRoot.contains(descendant)) {
+            return true;
+        }
+        // Check slot assigned nodes
+        const hasDescendantInAssignedNodes = Array.from(shadowRoot.querySelectorAll("slot")).some((slot) => slot
+            .assignedNodes({ flatten: true })
+            .some((assigned) => { var _a, _b; return ((_b = (_a = assigned).contains) === null || _b === void 0 ? void 0 : _b.call(_a, descendant)) || checkRecursive(assigned); }));
+        if (hasDescendantInAssignedNodes) {
+            return true;
+        }
+        // Check shadow and light DOM children
+        return Array.from(shadowRoot.children).some(checkRecursive) || Array.from(node.childNodes).some(checkRecursive);
+    };
+    return checkRecursive(ancestor);
+}
+/** Get the parent of passed element, accounting for shadow DOM.
+ * @param element The element whose parent is to be found.
+ */
+function getParentElement(element) {
+    // If the element is slotted, the direct rendered parent is the target slot in shadow DOM.
+    if (element.assignedSlot) {
+        return element.assignedSlot;
+    }
+    // If the element is in a shadow root, the parent is the shadow host.
+    if (element.parentNode instanceof ShadowRoot) {
+        return element.parentNode.host;
+    }
+    // Otherwise fall back to standard light DOM parent.
+    return element.parentElement;
+}
+/**
+ * Check if the `element` is visible within the `container` or in the viewport.
+ * @param element The element to check.
+ * @param container The container to check against, which must be the nearest scrollable ancestor.
+ */
+function isElementVisibleInContainer(element, container) {
+    const elemRect = element.getBoundingClientRect();
+    const documentWidth = element.ownerDocument.documentElement.clientWidth;
+    const documentHeight = element.ownerDocument.documentElement.clientHeight;
+    // Check if element is visible in viewport
+    const isVisibleInViewport = elemRect.bottom > 0 && elemRect.top < documentHeight && elemRect.right > 0 && elemRect.left < documentWidth;
+    // If container is the document element, only check viewport visibility
+    if (container === element.ownerDocument.documentElement || container === element.ownerDocument.body) {
+        return isVisibleInViewport;
+    }
+    // For other containers, check both container and viewport visibility
+    const containerRect = container.getBoundingClientRect();
+    const isVisibleInContainer = elemRect.bottom > containerRect.top &&
+        elemRect.top < containerRect.bottom &&
+        elemRect.right > containerRect.left &&
+        elemRect.left < containerRect.right;
+    return isVisibleInContainer && isVisibleInViewport;
+}
+/**
+ * Find the nearest containing block ancestor of an element.
+ * The containing block is determined based on the element's `position` value:
+ * - `static`, `sticky` or `relative`: nearest block container or root
+ * - `absolute`: nearest ancestor with `position` != `static`
+ * - `fixed`: nearest ancestor with properties that create a containing block (`transform`, `filter`, `will-change`, `backdrop-filter`, `perspective`, etc.).
+ * An ancestor with these properties will create a containing block for fixed positioned elements, making them behave like absolute positioned elements relative to that ancestor.
+ *
+ * @link https://developer.mozilla.org/en-US/docs/Web/CSS/Guides/Display/Containing_block#identifying_the_containing_block
+ * @param element The element for which to find the containing block
+ * @returns The containing block element if any, or the `documentElement`
+ */
+function findContainingBlockAncestor(element) {
+    let parent = getParentElement(element);
+    const elementPosition = window.getComputedStyle(element).position;
+    while (parent && parent !== element.ownerDocument.documentElement) {
+        const parentStyle = window.getComputedStyle(parent);
+        switch (elementPosition) {
+            case "fixed": {
+                const affectingProperties = [
+                    "filter",
+                    "transform",
+                    "translate",
+                    "perspective",
+                    "scale",
+                    "rotate",
+                    "backdrop-filter",
+                ];
+                if (affectingProperties.some((property) => parentStyle.getPropertyValue(property) !== "none") ||
+                    affectingProperties.some((property) => parentStyle.getPropertyValue("will-change").includes(property))) {
+                    return parent;
+                }
+                break;
+            }
+            case "absolute":
+                if (parentStyle.position !== "static") {
+                    return parent;
+                }
+                break;
+            // Handle position: static, relative, sticky (they all look for the nearest block container or root)
+            case "relative":
+            case "sticky":
+            case "static": {
+                const display = window.getComputedStyle(parent).display;
+                // Block containers: block, flex, grid, table, flow-root
+                if (display === "block" ||
+                    display === "flex" ||
+                    display === "grid" ||
+                    display === "table" ||
+                    display === "flow-root" ||
+                    display === "inline-block" ||
+                    display === "inline-flex" ||
+                    display === "inline-grid") {
+                    return parent;
+                }
+                break;
+            }
+        }
+        parent = getParentElement(parent);
+    }
+    return element.ownerDocument.documentElement;
+}
+/** Convert HTML to plain text */
+const getPlainText = (html) => {
+    const doc = new DOMParser().parseFromString(html, "text/html");
+    return doc.body.textContent || "";
+};
+/** Convert string to hex */
+const encodeString = (string) => string
+    .split("")
+    .map((c) => c.charCodeAt(0).toString(16))
+    .join("");
+
+exports.boolean = boolean;
+exports.colorFromId = colorFromId;
+exports.containsElement = containsElement;
+exports.convertJson = convertJson;
+exports.encodeString = encodeString;
+exports.findContainingBlockAncestor = findContainingBlockAncestor;
+exports.getClickedElement = getClickedElement;
+exports.getDevice = getDevice;
+exports.getElementTree = getElementTree;
+exports.getParentElement = getParentElement;
+exports.getPlainText = getPlainText;
+exports.handleEnterKeydSubmit = handleEnterKeydSubmit;
+exports.handleKeyboardSubmit = handleKeyboardSubmit;
+exports.isElementVisibleInContainer = isElementVisibleInContainer;
+exports.randomId = randomId;