@siemens/ix 5.0.0 → 5.1.0

package/dist/cjs/path-utils-CQKWhbQW.js

@@ -0,0 +1,169 @@
+'use strict';
+
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function buildComposedPath(id, childIdsByParent, path = new Set()) {
+    if (childIdsByParent[id]) {
+        path.add(id);
+    }
+    for (const parentId of Object.keys(childIdsByParent)) {
+        if (childIdsByParent[parentId].includes(id)) {
+            buildComposedPath(parentId, childIdsByParent, path).forEach((key) => path.add(key));
+        }
+    }
+    return path;
+}
+function buildPathIncluding(id, childIdsByParent) {
+    const path = buildComposedPath(id, childIdsByParent, new Set());
+    path.add(id);
+    return path;
+}
+function removeIdFromHierarchy(id, childIdsByParent, registeredIds) {
+    for (const registeredId of registeredIds) {
+        const childIds = childIdsByParent[registeredId];
+        if (childIds) {
+            const index = childIds.indexOf(id);
+            if (index > -1) {
+                childIds.splice(index, 1);
+            }
+        }
+    }
+    delete childIdsByParent[id];
+}
+function getParentId(childId, childIdsByParent) {
+    for (const parentId of Object.keys(childIdsByParent)) {
+        if (childIdsByParent[parentId].includes(childId)) {
+            return parentId;
+        }
+    }
+    return undefined;
+}
+
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class NestedOverlayStack {
+    policy;
+    dismissInstance;
+    instances = new Map();
+    childIdsByParent = {};
+    constructor(policy, dismissInstance) {
+        this.policy = policy;
+        this.dismissInstance = dismissInstance;
+    }
+    connect(instance) {
+        this.instances.set(instance.getId(), instance);
+    }
+    disconnect(instance) {
+        const id = instance.getId();
+        this.removeFromHierarchy(id);
+        this.instances.delete(id);
+    }
+    get(id) {
+        return this.instances.get(id);
+    }
+    keys() {
+        return [...this.instances.keys()];
+    }
+    forEach(callback) {
+        this.instances.forEach(callback);
+    }
+    values() {
+        return this.instances.values();
+    }
+    setChildIds(parentId, childIds) {
+        this.childIdsByParent[parentId] = childIds;
+    }
+    deleteChildIdsEntry(parentId) {
+        delete this.childIdsByParent[parentId];
+    }
+    getChildIds(parentId) {
+        return this.childIdsByParent[parentId] || [];
+    }
+    getChildIdsByParent() {
+        return this.childIdsByParent;
+    }
+    removeFromHierarchy(id) {
+        removeIdFromHierarchy(id, this.childIdsByParent, this.instances.keys());
+    }
+    buildComposedPath(id, path = new Set()) {
+        return buildComposedPath(id, this.childIdsByParent, path);
+    }
+    buildPathIncluding(id) {
+        return buildPathIncluding(id, this.childIdsByParent);
+    }
+    dismissChildren(parentId) {
+        for (const childId of this.getChildIds(parentId)) {
+            const child = this.instances.get(childId);
+            if (child) {
+                this.dismissInstance(child);
+            }
+        }
+    }
+    dismissAll(options = {}) {
+        const { ignorePolicyForIds = [], ignoreRelatedInHierarchy = false } = options;
+        this.forEach((instance) => {
+            const id = instance.getId();
+            const shouldIgnorePolicy = ignorePolicyForIds.includes(id);
+            const path = buildComposedPath(id, this.childIdsByParent, new Set());
+            if (ignorePolicyForIds.length > 0 && ignoreRelatedInHierarchy) {
+                let skipRelated = false;
+                for (const ignoreId of ignorePolicyForIds) {
+                    if (path.has(ignoreId)) {
+                        skipRelated = true;
+                        break;
+                    }
+                }
+                if (!skipRelated) {
+                    return;
+                }
+            }
+            if (!shouldIgnorePolicy && this.policy.blocksOutsideDismiss(instance)) {
+                return;
+            }
+            this.dismissInstance(instance);
+        });
+    }
+    dismissOthers(activeId) {
+        const path = this.buildPathIncluding(activeId);
+        this.forEach((instance) => {
+            if (!this.policy.blocksOutsideDismiss(instance) &&
+                !path.has(instance.getId())) {
+                this.dismissInstance(instance);
+            }
+        });
+    }
+}
+
+/*
+ * SPDX-FileCopyrightText: 2026 Siemens AG
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function pathIncludesTrigger(eventTargets, triggerAttribute) {
+    for (const eventTarget of eventTargets) {
+        if (eventTarget instanceof HTMLElement &&
+            eventTarget.hasAttribute(triggerAttribute)) {
+            return eventTarget;
+        }
+    }
+    return undefined;
+}
+
+exports.NestedOverlayStack = NestedOverlayStack;
+exports.getParentId = getParentId;
+exports.pathIncludesTrigger = pathIncludesTrigger;

package/dist/cjs/{shadow-dom-BG8VqeIu.js → shadow-dom-BL5F7RFW.js}

@@ -24,6 +24,18 @@ function hasSlottedElements(slot) {
     }
     return slot.assignedElements({ flatten: true }).length !== 0;
 }
+function hasSlottedContent(slot) {
+    if (!slot) {
+        return false;
+    }
+    if (hasSlottedElements(slot)) {
+        return true;
+    }
+    return slot
+        .assignedNodes({ flatten: true })
+        .some((node) => node.nodeType === Node.TEXT_NODE &&
+        (node.textContent ?? '').trim().length > 0);
+}
 function closestPassShadow(node, selector) {
     if (!node) {
         return null;
@@ -88,4 +100,5 @@ exports.closestElement = closestElement;
 exports.closestPassShadow = closestPassShadow;
 exports.getComposedPath = getComposedPath;
 exports.getSlottedElements = getSlottedElements;
+exports.hasSlottedContent = hasSlottedContent;
 exports.hasSlottedElements = hasSlottedElements;