genesys-spark-components 4.185.4 → 4.186.0

package/dist/cjs/gux-tree-multi.service-SP7ZA2lB.js

@@ -0,0 +1,313 @@
+'use strict';
+
+var index = require('./index-Bfx8AGPj.js');
+var whenEventIsFrom = require('./when-event-is-from-C6TjNoqM.js');
+
+function getTree(node) {
+    return node.closest('gux-tree-multi-beta');
+}
+// Utility functions for node type checking
+function isNode(item) {
+    const nodeTypes = ['GUX-LEAF-MULTI', 'GUX-BRANCH-MULTI'];
+    return nodeTypes.includes(item.tagName);
+}
+function isBranchNode(item) {
+    return item.tagName === 'GUX-BRANCH-MULTI';
+}
+function isLeafNode(item) {
+    return item.tagName === 'GUX-LEAF-MULTI';
+}
+function isOpenBranchNode(item) {
+    if (item.tagName === 'GUX-BRANCH-MULTI') {
+        return item.expanded;
+    }
+    return false;
+}
+function hasActiveNode(tree) {
+    return Boolean(getActiveNode(tree));
+}
+// Core tree traversal functions
+function getAllTreeNodes(tree) {
+    const nodes = [];
+    function getNodes(element) {
+        for (const child of Array.from(element.children)) {
+            if (isNode(child)) {
+                nodes.push(child);
+            }
+            if (isBranchNode(child)) {
+                getNodes(child);
+            }
+        }
+    }
+    getNodes(tree);
+    return nodes;
+}
+function getAllTreeLeafNodes(tree) {
+    const nodes = [];
+    function getNodes(element) {
+        for (const child of Array.from(element.children)) {
+            if (isLeafNode(child)) {
+                nodes.push(child);
+            }
+            if (isBranchNode(child)) {
+                getNodes(child);
+            }
+        }
+    }
+    getNodes(tree);
+    return nodes;
+}
+function getTreeNodes(tree) {
+    const nodes = [];
+    function getNodes(element) {
+        for (const child of Array.from(element.children)) {
+            if (isNode(child)) {
+                nodes.push(child);
+            }
+            if (isOpenBranchNode(child)) {
+                getNodes(child);
+            }
+        }
+    }
+    getNodes(tree);
+    return nodes;
+}
+function getAvailableTreeNodes(tree) {
+    const availableTreeNodes = getTreeNodes(tree).filter(node => {
+        return !node.disabled && !node.filtered;
+    });
+    return availableTreeNodes;
+}
+// Node getter functions
+function getActiveNode(tree) {
+    return getTreeNodes(tree).find(node => node.active);
+}
+function getFirstSelectedNode(tree) {
+    return getTreeNodes(tree).find(node => node.selected && !node.disabled && !node.filtered);
+}
+function getFirstNode(tree) {
+    return getAvailableTreeNodes(tree)[0];
+}
+function getLastNode(tree) {
+    const availableNodes = getAvailableTreeNodes(tree);
+    return availableNodes[availableNodes.length - 1];
+}
+function getNextNode(tree) {
+    if (hasActiveNode(tree) && getActiveNode(tree) !== getLastNode(tree)) {
+        const availableTreeNodes = getAvailableTreeNodes(tree);
+        const activeNode = getActiveNode(tree);
+        const activeNodeIndex = availableTreeNodes.indexOf(activeNode);
+        return availableTreeNodes[activeNodeIndex + 1];
+    }
+    return getFirstNode(tree);
+}
+function getPreviousNode(tree) {
+    if (hasActiveNode(tree)) {
+        const availableNodesList = getAvailableTreeNodes(tree);
+        const activeNodeIndex = availableNodesList.indexOf(getActiveNode(tree));
+        if (getActiveNode(tree) === getFirstNode(tree)) {
+            return getLastNode(tree);
+        }
+        return availableNodesList[activeNodeIndex - 1];
+    }
+    return getFirstNode(tree);
+}
+// Core setter functions
+function setActiveNode(tree, element) {
+    if (tree.disabled) {
+        clearActiveNode(tree);
+        return;
+    }
+    if (element) {
+        getTreeNodes(tree).forEach(node => {
+            const active = !node.disabled && !node.filtered && node === element;
+            node.active = active;
+            if (active) {
+                tree.setAttribute('aria-activedescendant', node.id);
+            }
+        });
+        element.scrollIntoView({ block: 'nearest' });
+    }
+}
+function clearActiveNode(tree) {
+    getAllTreeNodes(tree).forEach(node => {
+        node.active = false;
+    });
+    tree.removeAttribute('aria-activedescendant');
+}
+function expandAllParents(element) {
+    let parent = element.parentElement.closest('gux-branch-multi');
+    while (parent) {
+        parent.expanded = true;
+        parent = parent.parentElement.closest('gux-branch-multi');
+    }
+}
+function updateBranchState(branch) {
+    const childNodes = getAllTreeLeafNodes(branch);
+    const selectedChildren = childNodes.filter(child => child.selected);
+    if (selectedChildren.length === 0) {
+        branch.selected = false;
+        branch.indeterminate = false;
+    }
+    else if (selectedChildren.length === childNodes.length) {
+        branch.selected = true;
+        branch.indeterminate = false;
+    }
+    else {
+        branch.selected = false;
+        branch.indeterminate = true;
+    }
+}
+function updateDescendants(node, selected) {
+    for (const child of Array.from(node.children)) {
+        if (isNode(child)) {
+            const childNode = child;
+            if (!childNode.disabled && !childNode.filtered) {
+                childNode.selected = selected;
+                childNode.indeterminate = false;
+            }
+        }
+        if (isBranchNode(child)) {
+            updateDescendants(child, selected);
+        }
+    }
+}
+function updateParentStates(node) {
+    let parent = node.parentElement.closest('gux-branch-multi');
+    while (parent) {
+        updateBranchState(parent);
+        parent = parent.parentElement.closest('gux-branch-multi');
+    }
+}
+function updateTreeValue(tree) {
+    const selectedNodes = getAllTreeNodes(tree).filter(node => node.selected && node.value);
+    tree.value = selectedNodes.map(node => node.value).join(',');
+}
+// Public API - Active node management
+function setInitialActiveNode(tree) {
+    setActiveNode(tree, getFirstSelectedNode(tree) || getFirstNode(tree));
+}
+function setFirstNodeActive(tree) {
+    setActiveNode(tree, getFirstNode(tree));
+}
+function setLastNodeActive(tree) {
+    setActiveNode(tree, getLastNode(tree));
+}
+function setNextNodeActive(tree) {
+    setActiveNode(tree, getNextNode(tree));
+}
+function setPreviousNodeActive(tree) {
+    setActiveNode(tree, getPreviousNode(tree));
+}
+function setParentNodeActive(tree) {
+    const activeNode = getActiveNode(tree);
+    const parentNode = activeNode.parentElement.closest('gux-branch-multi');
+    setActiveNode(tree, parentNode);
+}
+function setChildNodeActive(tree, branch) {
+    const targetBranch = getActiveNode(tree);
+    const availableNodes = getAvailableTreeNodes(tree).filter(node => {
+        return targetBranch.contains(node);
+    });
+    if (availableNodes[0]) {
+        setActiveNode(tree, availableNodes[0]);
+    }
+}
+function hasChildSelected(branch) {
+    return getAllTreeNodes(branch).some(node => node.selected);
+}
+function hasParentDisabled(node) {
+    let parent = node.parentElement.closest('gux-branch-multi, gux-tree-multi-beta, fieldset');
+    while (parent) {
+        if (parent.disabled) {
+            return true;
+        }
+        parent = parent.parentElement.closest('gux-branch-multi, gux-tree-multi-beta, fieldset');
+    }
+    return false;
+}
+function forceUpdateTree(tree) {
+    getAllTreeNodes(tree).forEach(node => {
+        index.forceUpdate(node);
+    });
+}
+function toggleNodeSelection(tree, element) {
+    const newSelected = !element.selected;
+    element.selected = newSelected;
+    element.indeterminate = false;
+    // If it's a branch, update all descendants
+    if (isBranchNode(element)) {
+        updateDescendants(element, newSelected);
+    }
+    // Update parent states
+    updateParentStates(element);
+    updateTreeValue(tree);
+    element.scrollIntoView({ block: 'nearest' });
+}
+function setSelectedNodesByValue(tree, value) {
+    const values = value.split(',').map(v => v.trim());
+    const allNodes = getAllTreeNodes(tree);
+    allNodes.forEach(node => {
+        node.selected = values.includes(node.value);
+        node.indeterminate = false;
+    });
+    // Update branch states
+    allNodes
+        .filter(node => isBranchNode(node))
+        .forEach(branch => {
+        updateBranchState(branch);
+    });
+}
+function setInitialSelectedNodesByValue(tree, value) {
+    setSelectedNodesByValue(tree, value);
+    expandSelectedNodes(tree);
+}
+function expandSelectedNodes(tree) {
+    const allNodes = getAllTreeNodes(tree);
+    allNodes.forEach(node => {
+        if (node.selected) {
+            expandAllParents(node);
+        }
+    });
+}
+function getTreeSize(node) {
+    var _a;
+    return (_a = getTree(node)) === null || _a === void 0 ? void 0 : _a.size;
+}
+function getTreeAlignment(node) {
+    var _a;
+    return (_a = getTree(node)) === null || _a === void 0 ? void 0 : _a.alignment;
+}
+// Public API - Event handling
+function handleTreeNodeSpecificEvent({ event, onLeaf, onBranch }) {
+    let eventFromLeaf = false;
+    whenEventIsFrom.whenEventIsFrom('gux-leaf-multi', event, (leaf) => {
+        if (leaf.value) {
+            onLeaf(leaf);
+            eventFromLeaf = true;
+        }
+    });
+    if (!eventFromLeaf) {
+        whenEventIsFrom.whenEventIsFrom('gux-branch-multi', event, (branch) => {
+            onBranch(branch);
+        });
+    }
+}
+
+exports.clearActiveNode = clearActiveNode;
+exports.forceUpdateTree = forceUpdateTree;
+exports.getTreeAlignment = getTreeAlignment;
+exports.getTreeSize = getTreeSize;
+exports.handleTreeNodeSpecificEvent = handleTreeNodeSpecificEvent;
+exports.hasChildSelected = hasChildSelected;
+exports.hasParentDisabled = hasParentDisabled;
+exports.setChildNodeActive = setChildNodeActive;
+exports.setFirstNodeActive = setFirstNodeActive;
+exports.setInitialActiveNode = setInitialActiveNode;
+exports.setInitialSelectedNodesByValue = setInitialSelectedNodesByValue;
+exports.setLastNodeActive = setLastNodeActive;
+exports.setNextNodeActive = setNextNodeActive;
+exports.setParentNodeActive = setParentNodeActive;
+exports.setPreviousNodeActive = setPreviousNodeActive;
+exports.setSelectedNodesByValue = setSelectedNodesByValue;
+exports.toggleNodeSelection = toggleNodeSelection;

package/dist/cjs/gux-tree.service-w78yRmzF.js

@@ -0,0 +1,240 @@
+'use strict';
+
+var index = require('./index-Bfx8AGPj.js');
+var whenEventIsFrom = require('./when-event-is-from-C6TjNoqM.js');
+
+function getTree(node) {
+    return node.closest('gux-tree-beta');
+}
+// Utility functions for node type checking
+function isNode(item) {
+    const nodeTypes = ['GUX-LEAF', 'GUX-BRANCH'];
+    return nodeTypes.includes(item.tagName);
+}
+function isBranchNode(item) {
+    return item.tagName === 'GUX-BRANCH';
+}
+function isOpenBranchNode(item) {
+    if (item.tagName === 'GUX-BRANCH') {
+        return item.expanded;
+    }
+    return false;
+}
+function hasActiveNode(tree) {
+    return Boolean(getActiveNode(tree));
+}
+// Core tree traversal functions
+function getAllTreeNodes(tree) {
+    const nodes = [];
+    function getNodes(element) {
+        for (const child of Array.from(element.children)) {
+            if (isNode(child)) {
+                nodes.push(child);
+            }
+            if (isBranchNode(child)) {
+                getNodes(child);
+            }
+        }
+    }
+    getNodes(tree);
+    return nodes;
+}
+function getTreeNodes(tree) {
+    const nodes = [];
+    function getNodes(element) {
+        for (const child of Array.from(element.children)) {
+            if (isNode(child)) {
+                nodes.push(child);
+            }
+            if (isOpenBranchNode(child)) {
+                getNodes(child);
+            }
+        }
+    }
+    getNodes(tree);
+    return nodes;
+}
+function getAvailableTreeNodes(tree) {
+    const availableTreeNodes = getTreeNodes(tree).filter(node => {
+        return !node.disabled && !node.filtered;
+    });
+    return availableTreeNodes;
+}
+// Node getter functions
+function getActiveNode(tree) {
+    return getTreeNodes(tree).find(node => node.active);
+}
+function getFirstSelectedNode(tree) {
+    return getTreeNodes(tree).find(node => node.selected && !node.disabled && !node.filtered);
+}
+function getFirstNode(tree) {
+    return getAvailableTreeNodes(tree)[0];
+}
+function getLastNode(tree) {
+    const availableNodes = getAvailableTreeNodes(tree);
+    return availableNodes[availableNodes.length - 1];
+}
+function getNextNode(tree) {
+    if (hasActiveNode(tree) && getActiveNode(tree) !== getLastNode(tree)) {
+        const availableTreeNodes = getAvailableTreeNodes(tree);
+        const activeNode = getActiveNode(tree);
+        const activeNodeIndex = availableTreeNodes.indexOf(activeNode);
+        return availableTreeNodes[activeNodeIndex + 1];
+    }
+    return getFirstNode(tree);
+}
+function getPreviousNode(tree) {
+    if (hasActiveNode(tree)) {
+        const availableNodesList = getAvailableTreeNodes(tree);
+        const activeNodeIndex = availableNodesList.indexOf(getActiveNode(tree));
+        if (getActiveNode(tree) === getFirstNode(tree)) {
+            return getLastNode(tree);
+        }
+        return availableNodesList[activeNodeIndex - 1];
+    }
+    return getFirstNode(tree);
+}
+function getNodeByValue(tree, value) {
+    return getAllTreeNodes(tree).find(node => node.value === value);
+}
+// Core setter functions
+function setActiveNode(tree, element) {
+    if (tree.disabled) {
+        clearActiveNode(tree);
+        return;
+    }
+    if (element) {
+        getTreeNodes(tree).forEach(node => {
+            const active = !node.disabled && !node.filtered && node === element;
+            node.active = active;
+            if (active) {
+                tree.setAttribute('aria-activedescendant', node.id);
+            }
+        });
+        element.scrollIntoView({ block: 'nearest' });
+    }
+}
+function clearActiveNode(tree) {
+    getAllTreeNodes(tree).forEach(node => {
+        node.active = false;
+    });
+    tree.removeAttribute('aria-activedescendant');
+}
+function expandAllParents(element) {
+    let parent = element.parentElement.closest('gux-branch');
+    while (parent) {
+        parent.expanded = true;
+        parent = parent.parentElement.closest('gux-branch');
+    }
+}
+function setNoSelection(tree) {
+    getAllTreeNodes(tree).forEach(node => {
+        node.selected = false;
+    });
+}
+// Public API - Active node management
+function setInitialActiveNode(tree) {
+    setActiveNode(tree, getFirstSelectedNode(tree) || getFirstNode(tree));
+}
+function setFirstNodeActive(tree) {
+    setActiveNode(tree, getFirstNode(tree));
+}
+function setLastNodeActive(tree) {
+    setActiveNode(tree, getLastNode(tree));
+}
+function setNextNodeActive(tree) {
+    setActiveNode(tree, getNextNode(tree));
+}
+function setPreviousNodeActive(tree) {
+    setActiveNode(tree, getPreviousNode(tree));
+}
+function setParentNodeActive(tree) {
+    const activeNode = getActiveNode(tree);
+    const parentNode = activeNode.parentElement.closest('gux-branch');
+    setActiveNode(tree, parentNode);
+}
+function setChildNodeActive(tree, branch) {
+    const node = getActiveNode(branch);
+    const availableNodes = getAvailableTreeNodes(node);
+    if (availableNodes[0]) {
+        setActiveNode(tree, availableNodes[0]);
+    }
+}
+// Public API - Selection management
+function setSelectedNode(tree, element) {
+    if (element === null || element === void 0 ? void 0 : element.value) {
+        getAllTreeNodes(tree).forEach(node => {
+            node.selected = node === element;
+        });
+        tree.value = element.value;
+        element.scrollIntoView({ block: 'nearest' });
+    }
+}
+function setSelectedNodeByValue(tree, value) {
+    const element = getNodeByValue(tree, value);
+    if (element) {
+        expandAllParents(element);
+        setSelectedNode(tree, element);
+    }
+    else {
+        setNoSelection(tree);
+    }
+}
+function hasChildSelected(branch) {
+    return getAllTreeNodes(branch).some(node => node.selected);
+}
+function hasParentDisabled(node) {
+    let parent = node.parentElement.closest('gux-branch, gux-tree-beta, fieldset');
+    while (parent) {
+        if (parent.disabled) {
+            return true;
+        }
+        parent = parent.parentElement.closest('gux-branch, gux-tree-beta, fieldset');
+    }
+    return false;
+}
+function forceUpdateTree(tree) {
+    getAllTreeNodes(tree).forEach(node => {
+        index.forceUpdate(node);
+    });
+}
+function getTreeSize(node) {
+    var _a;
+    return (_a = getTree(node)) === null || _a === void 0 ? void 0 : _a.size;
+}
+function getTreeAlignment(node) {
+    var _a;
+    return (_a = getTree(node)) === null || _a === void 0 ? void 0 : _a.alignment;
+}
+// Public API - Event handling
+function handleTreeNodeSpecificEvent({ event, onLeaf, onBranch }) {
+    let eventFromLeaf = false;
+    whenEventIsFrom.whenEventIsFrom('gux-leaf', event, (leaf) => {
+        if (leaf.value) {
+            onLeaf(leaf);
+            eventFromLeaf = true;
+        }
+    });
+    if (!eventFromLeaf) {
+        whenEventIsFrom.whenEventIsFrom('gux-branch', event, (branch) => {
+            onBranch(branch);
+        });
+    }
+}
+
+exports.clearActiveNode = clearActiveNode;
+exports.forceUpdateTree = forceUpdateTree;
+exports.getTreeAlignment = getTreeAlignment;
+exports.getTreeSize = getTreeSize;
+exports.handleTreeNodeSpecificEvent = handleTreeNodeSpecificEvent;
+exports.hasChildSelected = hasChildSelected;
+exports.hasParentDisabled = hasParentDisabled;
+exports.setChildNodeActive = setChildNodeActive;
+exports.setFirstNodeActive = setFirstNodeActive;
+exports.setInitialActiveNode = setInitialActiveNode;
+exports.setLastNodeActive = setLastNodeActive;
+exports.setNextNodeActive = setNextNodeActive;
+exports.setParentNodeActive = setParentNodeActive;
+exports.setPreviousNodeActive = setPreviousNodeActive;
+exports.setSelectedNode = setSelectedNode;
+exports.setSelectedNodeByValue = setSelectedNodeByValue;

package/dist/cjs/index-Bfx8AGPj.js

@@ -150,6 +150,14 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
                         './gux-blank-state-beta.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-branch.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-branch.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-branch-multi.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-branch-multi.cjs.entry.js')); }).then(processMod, consoleError);
                 case 'gux-breadcrumb-item.cjs':
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
@@ -206,6 +214,14 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
                         './gux-label-info-beta.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-leaf.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-leaf.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-leaf-multi.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-leaf-multi.cjs.entry.js')); }).then(processMod, consoleError);
                 case 'gux-loading-message.cjs':
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
@@ -394,6 +410,14 @@ var loadModule = (cmpMeta, hostRef, hmrVersionId) => {
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */
                         './gux-toast.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-tree-beta.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-tree-beta.cjs.entry.js')); }).then(processMod, consoleError);
+                case 'gux-tree-multi-beta.cjs':
+                    return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
+                        /* webpackMode: "lazy" */
+                        './gux-tree-multi-beta.cjs.entry.js')); }).then(processMod, consoleError);
                 case 'gux-form-field-search.cjs':
                     return Promise.resolve().then(function () { return /*#__PURE__*/_interopNamespace(require(
                         /* webpackMode: "lazy" */