feat: Fluent UI Outlook Lite + connections mockup

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/FlatTree.js

@@ -0,0 +1,26 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlatTree", {
+    enumerable: true,
+    get: function() {
+        return FlatTree;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useFlatTree = require("./useFlatTree");
+const _useFlatTreeStylesstyles = require("./useFlatTreeStyles.styles");
+const _useFlatTreeContextValues = require("./useFlatTreeContextValues");
+const _renderFlatTree = require("./renderFlatTree");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const FlatTree = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useFlatTree.useFlatTree_unstable)(props, ref);
+    const contextValues = (0, _useFlatTreeContextValues.useFlatTreeContextValues_unstable)(state);
+    (0, _useFlatTreeStylesstyles.useFlatTreeStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useFlatTreeStyles_unstable')(state);
+    return (0, _renderFlatTree.renderFlatTree_unstable)(state, contextValues);
+});
+FlatTree.displayName = 'FlatTree';

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/FlatTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/FlatTree.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport type { FlatTreeProps } from './FlatTree.types';\nimport { useFlatTree_unstable } from './useFlatTree';\nimport { useFlatTreeStyles_unstable } from './useFlatTreeStyles.styles';\nimport { useFlatTreeContextValues_unstable } from './useFlatTreeContextValues';\nimport { renderFlatTree_unstable } from './renderFlatTree';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * The `FlatTree` component is a variation of the `Tree` component that deals with a flattened data structure.\n *\n * It should be used on cases where more complex interactions with a Tree is required.\n * On simple scenarios it is advised to simply use a nested structure instead.\n */\nexport const FlatTree: ForwardRefComponent<FlatTreeProps> = React.forwardRef((props, ref) => {\n  const state = useFlatTree_unstable(props, ref);\n  const contextValues = useFlatTreeContextValues_unstable(state);\n  useFlatTreeStyles_unstable(state);\n  useCustomStyleHook_unstable('useFlatTreeStyles_unstable')(state);\n\n  return renderFlatTree_unstable(state, contextValues);\n});\n\nFlatTree.displayName = 'FlatTree';\n"],"names":["React","useFlatTree_unstable","useFlatTreeStyles_unstable","useFlatTreeContextValues_unstable","renderFlatTree_unstable","useCustomStyleHook_unstable","FlatTree","forwardRef","props","ref","state","contextValues","displayName"],"mappings":"AAAA;;;;;;;;;;;;iEAEuB,QAAQ;6BAGM,gBAAgB;yCACV,6BAA6B;0CACtB,6BAA6B;gCACvC,mBAAmB;qCACf,kCAAkC;AAQvE,MAAMM,WAAAA,WAAAA,GAA+CN,OAAMO,UAAU,CAAC,CAACC,OAAOC;IACnF,MAAMC,YAAQT,iCAAAA,EAAqBO,OAAOC;IAC1C,MAAME,oBAAgBR,2DAAAA,EAAkCO;QACxDR,mDAAAA,EAA2BQ;QAC3BL,gDAAAA,EAA4B,8BAA8BK;IAE1D,WAAON,uCAAAA,EAAwBM,OAAOC;AACxC,GAAG;AAEHL,SAASM,WAAW,GAAG"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/FlatTree.types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/FlatTree.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/FlatTree.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, SelectionMode } from '@fluentui/react-utilities';\nimport type {\n  TreeSlots,\n  TreeCheckedChangeData,\n  TreeCheckedChangeEvent,\n  TreeNavigationData_unstable,\n  TreeNavigationEvent_unstable,\n  TreeOpenChangeData,\n  TreeOpenChangeEvent,\n  TreeSelectionValue,\n} from '../Tree/index';\nimport type { TreeItemValue } from '../TreeItem/index';\nimport type { TreeContextValue } from '../../contexts';\n\nexport type FlatTreeSlots = TreeSlots;\n\nexport type FlatTreeContextValues = {\n  tree: TreeContextValue;\n};\n\nexport type FlatTreeProps = ComponentProps<TreeSlots> & {\n  /**\n   * Indicates how navigation between a treeitem and its actions work\n   * - 'tree' (default): The default navigation, pressing right arrow key navigates inward the first inner children of a branch treeitem\n   * - 'treegrid': Pressing right arrow key navigate towards the actions of a treeitem\n   * @default 'tree'\n   */\n  navigationMode?: 'tree' | 'treegrid';\n  /**\n   * A tree item can have various appearances:\n   * - 'subtle' (default): The default tree item styles.\n   * - 'subtle-alpha': Minimizes emphasis on hovered or focused states.\n   * - 'transparent': Removes background color.\n   * @default 'subtle'\n   */\n  appearance?: 'subtle' | 'subtle-alpha' | 'transparent';\n  /**\n   * Size of the tree item.\n   * @default 'medium'\n   */\n  size?: 'small' | 'medium';\n  /**\n   * This refers to a list of ids of opened tree items.\n   * Controls the state of the open tree items.\n   * These property is ignored for subtrees.\n   */\n  openItems?: Iterable<TreeItemValue>;\n  /**\n   * Callback fired when the component changes value from open state.\n   * These property is ignored for subtrees.\n   *\n   * @param event - a React's Synthetic event\n   * @param data - A data object with relevant information,\n   * such as open value and type of interaction that created the event.\n   */\n  onOpenChange?(event: TreeOpenChangeEvent, data: TreeOpenChangeData): void;\n\n  /**\n   * Callback fired when navigation happens inside the component.\n   * These property is ignored for subtrees.\n   *\n   * FIXME: This method is not ideal, as navigation should be handled internally by tabster.\n   *\n   * @param event - a React's Synthetic event\n   * @param data - A data object with relevant information,\n   */\n  onNavigation?(event: TreeNavigationEvent_unstable, data: TreeNavigationData_unstable): void;\n\n  /**\n   * This refers to the selection mode of the tree.\n   * - undefined: No selection can be done.\n   * - 'single': Only one tree item can be selected, radio buttons are rendered.\n   * - 'multiselect': Multiple tree items can be selected, checkboxes are rendered.\n   *\n   * @default undefined\n   */\n  selectionMode?: SelectionMode;\n  /**\n   * This refers to a list of ids of checked tree items, or a list of tuples of ids and checked state.\n   * Controls the state of the checked tree items.\n   * These property is ignored for subtrees.\n   */\n  checkedItems?: Iterable<TreeItemValue | [TreeItemValue, TreeSelectionValue]>;\n  /**\n   * Callback fired when the component changes value from checked state.\n   * These property is ignored for subtrees.\n   *\n   * @param event - a React's Synthetic event\n   * @param data - A data object with relevant information,\n   * such as checked value and type of interaction that created the event.\n   */\n  onCheckedChange?(event: TreeCheckedChangeEvent, data: TreeCheckedChangeData): void;\n};\n\nexport type FlatTreeState = ComponentState<FlatTreeSlots> &\n  TreeContextValue & {\n    open: boolean;\n  };\n"],"names":[],"mappings":""}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/index.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    FlatTree: function() {
+        return _FlatTree.FlatTree;
+    },
+    flatTreeClassNames: function() {
+        return _useFlatTreeStylesstyles.flatTreeClassNames;
+    },
+    renderFlatTree_unstable: function() {
+        return _renderFlatTree.renderFlatTree_unstable;
+    },
+    useFlatTreeContextValues_unstable: function() {
+        return _useFlatTreeContextValues.useFlatTreeContextValues_unstable;
+    },
+    useFlatTreeStyles_unstable: function() {
+        return _useFlatTreeStylesstyles.useFlatTreeStyles_unstable;
+    },
+    useFlatTree_unstable: function() {
+        return _useFlatTree.useFlatTree_unstable;
+    },
+    useHeadlessFlatTree_unstable: function() {
+        return _useHeadlessFlatTree.useHeadlessFlatTree_unstable;
+    }
+});
+const _FlatTree = require("./FlatTree");
+const _useHeadlessFlatTree = require("./useHeadlessFlatTree");
+const _useFlatTree = require("./useFlatTree");
+const _useFlatTreeStylesstyles = require("./useFlatTreeStyles.styles");
+const _useFlatTreeContextValues = require("./useFlatTreeContextValues");
+const _renderFlatTree = require("./renderFlatTree");

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/index.ts"],"sourcesContent":["export { FlatTree } from './FlatTree';\nexport type { FlatTreeContextValues, FlatTreeProps, FlatTreeSlots, FlatTreeState } from './FlatTree.types';\nexport type {\n  HeadlessFlatTree,\n  HeadlessFlatTreeItem,\n  HeadlessFlatTreeItemProps,\n  HeadlessFlatTreeOptions,\n} from './useHeadlessFlatTree';\nexport { useHeadlessFlatTree_unstable } from './useHeadlessFlatTree';\nexport { useFlatTree_unstable } from './useFlatTree';\nexport { flatTreeClassNames, useFlatTreeStyles_unstable } from './useFlatTreeStyles.styles';\nexport { useFlatTreeContextValues_unstable } from './useFlatTreeContextValues';\nexport { renderFlatTree_unstable } from './renderFlatTree';\n"],"names":["FlatTree","useHeadlessFlatTree_unstable","useFlatTree_unstable","flatTreeClassNames","useFlatTreeStyles_unstable","useFlatTreeContextValues_unstable","renderFlatTree_unstable"],"mappings":";;;;;;;;;;;IAASA;iCAAQ;;IAURG;0DAAkB;;;eAElBG,uCAAuB;;;eADvBD,2DAAiC;;;eADbD,mDAA0B;;;eAD9CF,iCAAoB;;;eADpBD,iDAA4B;;;0BARZ,aAAa;qCAQO,wBAAwB;6BAChC,gBAAgB;yCACU,6BAA6B;0CAC1C,6BAA6B;gCACvC,mBAAmB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/renderFlatTree.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderFlatTree_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderFlatTree_unstable;
+    }
+});
+const _Tree = require("../../Tree");
+const renderFlatTree_unstable = _Tree.renderTree_unstable;

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/renderFlatTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/renderFlatTree.ts"],"sourcesContent":["import { renderTree_unstable } from '../../Tree';\nimport type { FlatTreeContextValues, FlatTreeState } from './FlatTree.types';\nimport type { JSXElement } from '@fluentui/react-utilities';\nexport const renderFlatTree_unstable: (state: FlatTreeState, contextValues: FlatTreeContextValues) => JSXElement =\n  renderTree_unstable;\n"],"names":["renderTree_unstable","renderFlatTree_unstable"],"mappings":";;;;;;;;;;sBAAoC,aAAa;AAG1C,MAAMC,0BACXD,yBAAAA,CAAoB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatControllableCheckedItems.js

@@ -0,0 +1,107 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createNextFlatCheckedItems: function() {
+        return createNextFlatCheckedItems;
+    },
+    useFlatControllableCheckedItems: function() {
+        return useFlatControllableCheckedItems;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactutilities = require("@fluentui/react-utilities");
+const _ImmutableMap = require("../../utils/ImmutableMap");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _createCheckedItems = require("../../utils/createCheckedItems");
+function useFlatControllableCheckedItems(props, headlessTree) {
+    return (0, _reactutilities.useControllableState)({
+        initialState: _ImmutableMap.ImmutableMap.empty,
+        state: _react.useMemo(()=>props.selectionMode ? props.checkedItems && (0, _createCheckedItems.createCheckedItems)(props.checkedItems) : undefined, [
+            props.checkedItems,
+            props.selectionMode
+        ]),
+        defaultState: props.defaultCheckedItems ? ()=>initializeCheckedItems(props, headlessTree) : undefined
+    });
+}
+function createNextFlatCheckedItems(data, previousCheckedItems, headlessTree) {
+    if (data.selectionMode === 'single') {
+        return _ImmutableMap.ImmutableMap.from([
+            [
+                data.value,
+                data.checked
+            ]
+        ]);
+    }
+    const treeItem = headlessTree.get(data.value);
+    if (!treeItem) {
+        if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.error(`@fluentui/react-tree [useHeadlessFlatTree]:
+Tree item ${data.value} not found.`);
+        }
+        return previousCheckedItems;
+    }
+    // Calling `ImmutableMap.set()` creates a new ImmutableMap - avoid this in loops.
+    // Instead write all updates to a native Map and create a new ImmutableMap at the end.
+    // Note that all descendants of the toggled item are processed even if they are collapsed,
+    // making the choice of algorithm more important.
+    const nextCheckedItemsMap = new Map(_ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(previousCheckedItems));
+    // The toggled item itself
+    nextCheckedItemsMap.set(data.value, data.checked);
+    // Descendant updates
+    for (const children of headlessTree.subtree(data.value)){
+        nextCheckedItemsMap.set(children.value, data.checked);
+    }
+    // Ancestor updates - must be done after adding descendants and the toggle item.
+    // If any ancestor is mixed, all ancestors above it are mixed too.
+    let isAncestorsMixed = false;
+    for (const ancestor of headlessTree.ancestors(treeItem.value)){
+        if (isAncestorsMixed) {
+            nextCheckedItemsMap.set(ancestor.value, 'mixed');
+            continue;
+        }
+        // For each ancestor, if all of its children now have the same checked state as the toggled item,
+        // set the ancestor to that checked state too. Otherwise it is 'mixed'.
+        let childrenWithSameState = 0;
+        for (const child of headlessTree.children(ancestor.value)){
+            if ((nextCheckedItemsMap.get(child.value) || false) === data.checked) {
+                childrenWithSameState++;
+            }
+        }
+        if (childrenWithSameState === ancestor.childrenValues.length) {
+            nextCheckedItemsMap.set(ancestor.value, data.checked);
+        } else {
+            nextCheckedItemsMap.set(ancestor.value, 'mixed');
+            isAncestorsMixed = true;
+        }
+    }
+    const nextCheckedItems = _ImmutableMap.ImmutableMap.from(nextCheckedItemsMap);
+    return nextCheckedItems;
+}
+function initializeCheckedItems(props, headlessTree) {
+    if (!props.selectionMode) {
+        return _ImmutableMap.ImmutableMap.empty;
+    }
+    let state = (0, _createCheckedItems.createCheckedItems)(props.defaultCheckedItems);
+    // if selectionMode is multiselect, we need to calculate the checked state of all children
+    // and ancestors of the defaultCheckedItems
+    if (props.selectionMode === 'multiselect') {
+        for (const [value, checked] of state){
+            state = createNextFlatCheckedItems({
+                value,
+                checked,
+                selectionMode: props.selectionMode
+            }, state, headlessTree);
+        }
+    }
+    return state;
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTree.js

@@ -0,0 +1,69 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useFlatTree_unstable", {
+    enumerable: true,
+    get: function() {
+        return useFlatTree_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useRootTree = require("../../hooks/useRootTree");
+const _reactutilities = require("@fluentui/react-utilities");
+const _useFlatTreeNavigation = require("../../hooks/useFlatTreeNavigation");
+const _useSubtree = require("../../hooks/useSubtree");
+const _ImmutableSet = require("../../utils/ImmutableSet");
+const _ImmutableMap = require("../../utils/ImmutableMap");
+const _subtreeContext = require("../../contexts/subtreeContext");
+const useFlatTree_unstable = (props, ref)=>{
+    'use no memo';
+    const isRoot = _react.useContext(_subtreeContext.SubtreeContext) === undefined;
+    // as level is static, this doesn't break rule of hooks
+    // and if this becomes an issue later on, this can be easily converted
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return isRoot ? useRootFlatTree(props, ref) : useSubFlatTree(props, ref);
+};
+function useRootFlatTree(props, ref) {
+    const navigation = (0, _useFlatTreeNavigation.useFlatTreeNavigation)(props.navigationMode);
+    return Object.assign((0, _useRootTree.useRootTree)({
+        ...props,
+        onNavigation: (0, _reactutilities.useEventCallback)((event, data)=>{
+            var _props_onNavigation;
+            (_props_onNavigation = props.onNavigation) === null || _props_onNavigation === void 0 ? void 0 : _props_onNavigation.call(props, event, data);
+            if (!event.isDefaultPrevented()) {
+                navigation.navigate(data);
+            }
+        })
+    }, (0, _reactutilities.useMergedRefs)(ref, navigation.rootRef)), {
+        treeType: 'flat',
+        forceUpdateRovingTabIndex: navigation.forceUpdateRovingTabIndex
+    });
+}
+function useSubFlatTree(props, ref) {
+    if (process.env.NODE_ENV === 'development') {
+        throw new Error(`@fluentui/react-tree [useFlatTree]:
+Subtrees are not allowed in a FlatTree!
+You cannot use a <FlatTree> component inside of another <FlatTree> nor a <Tree> component!`);
+    }
+    return {
+        ...(0, _useSubtree.useSubtree)(props, ref),
+        // ------ defaultTreeContextValue
+        level: 0,
+        contextType: 'root',
+        treeType: 'nested',
+        selectionMode: 'none',
+        openItems: _ImmutableSet.ImmutableSet.empty,
+        checkedItems: _ImmutableMap.ImmutableMap.empty,
+        requestTreeResponse: noop,
+        forceUpdateRovingTabIndex: noop,
+        appearance: 'subtle',
+        size: 'medium',
+        // ------ defaultTreeContextValue
+        open: false
+    };
+}
+function noop() {
+/* do nothing */ }

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/useFlatTree.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useRootTree } from '../../hooks/useRootTree';\nimport { FlatTreeProps, FlatTreeState } from './FlatTree.types';\nimport { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport { useFlatTreeNavigation } from '../../hooks/useFlatTreeNavigation';\nimport { useSubtree } from '../../hooks/useSubtree';\nimport { ImmutableSet } from '../../utils/ImmutableSet';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport { SubtreeContext } from '../../contexts/subtreeContext';\n\nexport const useFlatTree_unstable: (props: FlatTreeProps, ref: React.Ref<HTMLElement>) => FlatTreeState = (\n  props,\n  ref,\n) => {\n  'use no memo';\n\n  const isRoot = React.useContext(SubtreeContext) === undefined;\n  // as level is static, this doesn't break rule of hooks\n  // and if this becomes an issue later on, this can be easily converted\n  // eslint-disable-next-line react-hooks/rules-of-hooks\n  return isRoot ? useRootFlatTree(props, ref) : useSubFlatTree(props, ref);\n};\n\nfunction useRootFlatTree(props: FlatTreeProps, ref: React.Ref<HTMLElement>): FlatTreeState {\n  const navigation = useFlatTreeNavigation(props.navigationMode);\n\n  return Object.assign(\n    useRootTree(\n      {\n        ...props,\n        onNavigation: useEventCallback((event, data) => {\n          props.onNavigation?.(event, data);\n          if (!event.isDefaultPrevented()) {\n            navigation.navigate(data);\n          }\n        }),\n      },\n      useMergedRefs(ref, navigation.rootRef),\n    ),\n    {\n      treeType: 'flat',\n      forceUpdateRovingTabIndex: navigation.forceUpdateRovingTabIndex,\n    } as const,\n  );\n}\n\nfunction useSubFlatTree(props: FlatTreeProps, ref: React.Ref<HTMLElement>): FlatTreeState {\n  if (process.env.NODE_ENV === 'development') {\n    throw new Error(/* #__DE-INDENT__ */ `\n      @fluentui/react-tree [useFlatTree]:\n      Subtrees are not allowed in a FlatTree!\n      You cannot use a <FlatTree> component inside of another <FlatTree> nor a <Tree> component!\n    `);\n  }\n  return {\n    ...useSubtree(props, ref),\n    // ------ defaultTreeContextValue\n    level: 0,\n    contextType: 'root',\n    treeType: 'nested',\n    selectionMode: 'none',\n    openItems: ImmutableSet.empty,\n    checkedItems: ImmutableMap.empty,\n    requestTreeResponse: noop,\n    forceUpdateRovingTabIndex: noop,\n    appearance: 'subtle',\n    size: 'medium',\n    // ------ defaultTreeContextValue\n    open: false,\n  };\n}\n\nfunction noop() {\n  /* do nothing */\n}\n"],"names":["React","useRootTree","useEventCallback","useMergedRefs","useFlatTreeNavigation","useSubtree","ImmutableSet","ImmutableMap","SubtreeContext","useFlatTree_unstable","props","ref","isRoot","useContext","undefined","useRootFlatTree","useSubFlatTree","navigation","navigationMode","Object","assign","onNavigation","event","data","isDefaultPrevented","navigate","rootRef","treeType","forceUpdateRovingTabIndex","process","env","NODE_ENV","Error","level","contextType","selectionMode","openItems","empty","checkedItems","requestTreeResponse","noop","appearance","size","open"],"mappings":"AAAA;;;;;+BAYaS;;;;;;;iEAVU,QAAQ;6BACH,0BAA0B;gCAEN,4BAA4B;uCACtC,oCAAoC;4BAC/C,yBAAyB;8BACvB,2BAA2B;8BAC3B,2BAA2B;gCACzB,gCAAgC;AAExD,6BAAmG,CACxGC,OACAC;IAEA;IAEA,MAAMC,SAASZ,OAAMa,UAAU,CAACL,8BAAAA,MAAoBM;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOF,SAASG,gBAAgBL,OAAOC,OAAOK,eAAeN,OAAOC;AACtE,EAAE;AAEF,SAASI,gBAAgBL,KAAoB,EAAEC,GAA2B;IACxE,MAAMM,iBAAab,4CAAAA,EAAsBM,MAAMQ,cAAc;IAE7D,OAAOC,OAAOC,MAAM,KAClBnB,wBAAAA,EACE;QACE,GAAGS,KAAK;QACRW,kBAAcnB,gCAAAA,EAAiB,CAACoB,OAAOC;gBACrCb;YAAAA,uBAAAA,MAAMW,YAAAA,AAAY,MAAA,QAAlBX,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBY,OAAOC;YAC5B,IAAI,CAACD,MAAME,kBAAkB,IAAI;gBAC/BP,WAAWQ,QAAQ,CAACF;YACtB;QACF;IACF,OACApB,6BAAAA,EAAcQ,KAAKM,WAAWS,OAAO,IAEvC;QACEC,UAAU;QACVC,2BAA2BX,WAAWW,yBAAyB;IACjE;AAEJ;AAEA,SAASZ,eAAeN,KAAoB,EAAEC,GAA2B;IACvE,IAAIkB,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,MAAM,IAAIC,MAA2B,CAAC;;0FAItC,CAAC;IACH;IACA,OAAO;QACL,OAAG3B,sBAAAA,EAAWK,OAAOC,IAAI;QACzB,iCAAiC;QACjCsB,OAAO;QACPC,aAAa;QACbP,UAAU;QACVQ,eAAe;QACfC,WAAW9B,0BAAAA,CAAa+B,KAAK;QAC7BC,cAAc/B,0BAAAA,CAAa8B,KAAK;QAChCE,qBAAqBC;QACrBZ,2BAA2BY;QAC3BC,YAAY;QACZC,MAAM;QACN,iCAAiC;QACjCC,MAAM;IACR;AACF;AAEA,SAASH;AACP,cAAc,GAChB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeContextValues.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useFlatTreeContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useFlatTreeContextValues_unstable;
+    }
+});
+const useFlatTreeContextValues_unstable = (state)=>{
+    const { openItems, level, contextType, treeType, checkedItems, selectionMode, navigationMode, appearance, size, requestTreeResponse, forceUpdateRovingTabIndex } = state;
+    /**
+   * This context is created with "@fluentui/react-context-selector",
+   * there is no sense to memoize it
+   */ const tree = {
+        treeType,
+        size,
+        openItems,
+        appearance,
+        checkedItems,
+        selectionMode,
+        navigationMode,
+        contextType,
+        level,
+        requestTreeResponse,
+        forceUpdateRovingTabIndex
+    };
+    return {
+        tree
+    };
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/useFlatTreeContextValues.ts"],"sourcesContent":["import type { TreeContextValue } from '../../contexts';\nimport type { FlatTreeContextValues, FlatTreeState } from './FlatTree.types';\n\nexport const useFlatTreeContextValues_unstable = (state: FlatTreeState): FlatTreeContextValues => {\n  const {\n    openItems,\n    level,\n    contextType,\n    treeType,\n    checkedItems,\n    selectionMode,\n    navigationMode,\n    appearance,\n    size,\n    requestTreeResponse,\n    forceUpdateRovingTabIndex,\n  } = state;\n  /**\n   * This context is created with \"@fluentui/react-context-selector\",\n   * there is no sense to memoize it\n   */\n  const tree: TreeContextValue = {\n    treeType,\n    size,\n    openItems,\n    appearance,\n    checkedItems,\n    selectionMode,\n    navigationMode,\n    contextType,\n    level,\n    requestTreeResponse,\n    forceUpdateRovingTabIndex,\n  };\n\n  return { tree };\n};\n"],"names":["useFlatTreeContextValues_unstable","state","openItems","level","contextType","treeType","checkedItems","selectionMode","navigationMode","appearance","size","requestTreeResponse","forceUpdateRovingTabIndex","tree"],"mappings":";;;;+BAGaA;;;;;;AAAN,0CAA0C,CAACC;IAChD,MAAM,EACJC,SAAS,EACTC,KAAK,EACLC,WAAW,EACXC,QAAQ,EACRC,YAAY,EACZC,aAAa,EACbC,cAAc,EACdC,UAAU,EACVC,IAAI,EACJC,mBAAmB,EACnBC,yBAAyB,EAC1B,GAAGX;IACJ;;;GAGC,GACD,MAAMY,OAAyB;QAC7BR;QACAK;QACAR;QACAO;QACAH;QACAC;QACAC;QACAJ;QACAD;QACAQ;QACAC;IACF;IAEA,OAAO;QAAEC;IAAK;AAChB,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.js

@@ -0,0 +1,32 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    flatTreeClassNames: function() {
+        return flatTreeClassNames;
+    },
+    useFlatTreeStyles_unstable: function() {
+        return useFlatTreeStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const flatTreeClassNames = {
+    root: 'fui-FlatTree'
+};
+const useBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rnv2ez3", null, [
+    ".rnv2ez3{display:flex;flex-direction:column;row-gap:var(--spacingVerticalXXS);}"
+]);
+const useFlatTreeStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(flatTreeClassNames.root, baseStyles, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useFlatTreeStyles.styles.js"],"sourcesContent":["'use client';\nimport { makeResetStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const flatTreeClassNames = {\n    root: 'fui-FlatTree'\n};\nconst useBaseStyles = makeResetStyles({\n    display: 'flex',\n    flexDirection: 'column',\n    rowGap: tokens.spacingVerticalXXS\n});\nexport const useFlatTreeStyles_unstable = (state)=>{\n    'use no memo';\n    const baseStyles = useBaseStyles();\n    state.root.className = mergeClasses(flatTreeClassNames.root, baseStyles, state.root.className);\n    return state;\n};\n"],"names":["__resetStyles","mergeClasses","tokens","flatTreeClassNames","root","useBaseStyles","useFlatTreeStyles_unstable","state","baseStyles","className"],"mappings":"AAAA,YAAY;;;;;;;;;;;;sBAGmB;;;8BAQQ;;;;uBAVO,gBAAgB;AAEvD,MAAMG,qBAAqB;IAC9BC,IAAI,EAAE;AACV,CAAC;AACD,MAAMC,aAAa,GAAA,WAAA,OAAGL,oBAAA,EAAA,WAAA,MAAA;IAAA;CAIrB,CAAC;AACK,MAAMM,8BAA8BC,KAAK,IAAG;IAC/C,aAAa;IACb,MAAMC,UAAU,GAAGH,aAAa,CAAC,CAAC;IAClCE,KAAK,CAACH,IAAI,CAACK,SAAS,OAAGR,mBAAY,EAACE,kBAAkB,CAACC,IAAI,EAAEI,UAAU,EAAED,KAAK,CAACH,IAAI,CAACK,SAAS,CAAC;IAC9F,OAAOF,KAAK;AAChB,CAAC"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.raw.js

@@ -0,0 +1,35 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    flatTreeClassNames: function() {
+        return flatTreeClassNames;
+    },
+    useFlatTreeStyles_unstable: function() {
+        return useFlatTreeStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reacttheme = require("@fluentui/react-theme");
+const flatTreeClassNames = {
+    root: 'fui-FlatTree'
+};
+const useBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    flexDirection: 'column',
+    rowGap: _reacttheme.tokens.spacingVerticalXXS
+});
+const useFlatTreeStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    state.root.className = (0, _react.mergeClasses)(flatTreeClassNames.root, baseStyles, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.raw.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTree/useFlatTreeStyles.styles.ts"],"sourcesContent":["'use client';\n\nimport { makeResetStyles, mergeClasses } from '@griffel/react';\nimport type { SlotClassNames } from '@fluentui/react-utilities';\nimport { tokens } from '@fluentui/react-theme';\nimport { FlatTreeSlots, FlatTreeState } from './FlatTree.types';\n\nexport const flatTreeClassNames: SlotClassNames<Omit<FlatTreeSlots, 'collapseMotion'>> = {\n  root: 'fui-FlatTree',\n};\n\nconst useBaseStyles = makeResetStyles({\n  display: 'flex',\n  flexDirection: 'column',\n  rowGap: tokens.spacingVerticalXXS,\n});\n\nexport const useFlatTreeStyles_unstable = (state: FlatTreeState): FlatTreeState => {\n  'use no memo';\n\n  const baseStyles = useBaseStyles();\n  state.root.className = mergeClasses(flatTreeClassNames.root, baseStyles, state.root.className);\n  return state;\n};\n"],"names":["makeResetStyles","mergeClasses","tokens","flatTreeClassNames","root","useBaseStyles","display","flexDirection","rowGap","spacingVerticalXXS","useFlatTreeStyles_unstable","state","baseStyles","className"],"mappings":"AAAA;;;;;;;;;;;;sBAOaG;;;8BAUAO;;;;uBAfiC,iBAAiB;4BAExC,wBAAwB;AAGxC,MAAMP,qBAA4E;IACvFC,MAAM;AACR,EAAE;AAEF,MAAMC,oBAAgBL,sBAAAA,EAAgB;IACpCM,SAAS;IACTC,eAAe;IACfC,QAAQN,kBAAAA,CAAOO,kBAAkB;AACnC;AAEO,MAAMC,6BAA6B,CAACC;IACzC;IAEA,MAAMC,aAAaP;IACnBM,MAAMP,IAAI,CAACS,SAAS,OAAGZ,mBAAAA,EAAaE,mBAAmBC,IAAI,EAAEQ,YAAYD,MAAMP,IAAI,CAACS,SAAS;IAC7F,OAAOF;AACT,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTree/useHeadlessFlatTree.js

@@ -0,0 +1,118 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useHeadlessFlatTree_unstable", {
+    enumerable: true,
+    get: function() {
+        return useHeadlessFlatTree_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _reactutilities = require("@fluentui/react-utilities");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _createHeadlessTree = require("../../utils/createHeadlessTree");
+const _tokens = require("../../utils/tokens");
+const _useFlatTreeNavigation = require("../../hooks/useFlatTreeNavigation");
+const _useControllableOpenItems = require("../../hooks/useControllableOpenItems");
+const _getTreeItemValueFromElement = require("../../utils/getTreeItemValueFromElement");
+const _ImmutableSet = require("../../utils/ImmutableSet");
+const _useFlatControllableCheckedItems = require("./useFlatControllableCheckedItems");
+const _ImmutableMap = require("../../utils/ImmutableMap");
+function useHeadlessFlatTree_unstable(props, options = {}) {
+    'use no memo';
+    const headlessTree = _react.useMemo(()=>(0, _createHeadlessTree.createHeadlessTree)(props), [
+        props
+    ]);
+    const [openItems, setOpenItems] = (0, _useControllableOpenItems.useControllableOpenItems)(options);
+    const [checkedItems, setCheckedItems] = (0, _useFlatControllableCheckedItems.useFlatControllableCheckedItems)(options, headlessTree);
+    const navigation = (0, _useFlatTreeNavigation.useFlatTreeNavigation)();
+    const treeRef = _react.useRef(null);
+    const handleOpenChange = (0, _reactutilities.useEventCallback)((event, data)=>{
+        var _options_onOpenChange;
+        const nextOpenItems = (0, _useControllableOpenItems.createNextOpenItems)(data, openItems);
+        (_options_onOpenChange = options.onOpenChange) === null || _options_onOpenChange === void 0 ? void 0 : _options_onOpenChange.call(options, event, {
+            ...data,
+            openItems: _ImmutableSet.ImmutableSet.dangerouslyGetInternalSet(nextOpenItems)
+        });
+        setOpenItems(nextOpenItems);
+    });
+    const handleCheckedChange = (0, _reactutilities.useEventCallback)((event, data)=>{
+        var _options_onCheckedChange;
+        const nextCheckedItems = (0, _useFlatControllableCheckedItems.createNextFlatCheckedItems)(data, checkedItems, headlessTree);
+        (_options_onCheckedChange = options.onCheckedChange) === null || _options_onCheckedChange === void 0 ? void 0 : _options_onCheckedChange.call(options, event, {
+            ...data,
+            checkedItems: _ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(nextCheckedItems)
+        });
+        setCheckedItems(nextCheckedItems);
+    });
+    const getNextNavigableItem = (0, _reactutilities.useEventCallback)((visibleItems, data)=>{
+        const item = headlessTree.get(data.value);
+        if (item) {
+            switch(data.type){
+                case _tokens.treeDataTypes.TypeAhead:
+                    return item;
+                case _tokens.treeDataTypes.ArrowLeft:
+                    return headlessTree.get(item.parentValue);
+                case _tokens.treeDataTypes.ArrowRight:
+                    return visibleItems[item.index + 1];
+                case _tokens.treeDataTypes.End:
+                    return visibleItems[visibleItems.length - 1];
+                case _tokens.treeDataTypes.Home:
+                    return visibleItems[0];
+                case _tokens.treeDataTypes.ArrowDown:
+                    return visibleItems[item.index + 1];
+                case _tokens.treeDataTypes.ArrowUp:
+                    return visibleItems[item.index - 1];
+            }
+        }
+    });
+    const getElementFromItem = _react.useCallback((item)=>{
+        var _treeRef_current;
+        return (_treeRef_current = treeRef.current) === null || _treeRef_current === void 0 ? void 0 : _treeRef_current.querySelector(`[${_getTreeItemValueFromElement.dataTreeItemValueAttrName}="${item.value}"]`);
+    }, []);
+    const ref = (0, _reactutilities.useMergedRefs)(treeRef, navigation.rootRef);
+    const getTreeProps = _react.useCallback(()=>{
+        var _options_onNavigation;
+        return {
+            ref,
+            openItems,
+            selectionMode: options.selectionMode,
+            checkedItems,
+            onOpenChange: handleOpenChange,
+            onCheckedChange: handleCheckedChange,
+            onNavigation: (_options_onNavigation = options.onNavigation) !== null && _options_onNavigation !== void 0 ? _options_onNavigation : noop
+        };
+    }, // eslint-disable-next-line react-hooks/exhaustive-deps
+    [
+        openItems,
+        checkedItems,
+        options.selectionMode,
+        options.onNavigation
+    ]);
+    const items = _react.useCallback(()=>headlessTree.visibleItems(openItems), [
+        openItems,
+        headlessTree
+    ]);
+    const getItem = _react.useCallback((value)=>headlessTree.get(value), [
+        headlessTree
+    ]);
+    return _react.useMemo(()=>({
+            navigate: navigation.navigate,
+            getTreeProps,
+            getNextNavigableItem,
+            getElementFromItem,
+            items,
+            getItem
+        }), [
+        navigation.navigate,
+        getTreeProps,
+        getNextNavigableItem,
+        getElementFromItem,
+        items,
+        getItem
+    ]);
+}
+/** @internal */ function noop() {
+/* noop */ }

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/FlatTreeItem.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlatTreeItem", {
+    enumerable: true,
+    get: function() {
+        return FlatTreeItem;
+    }
+});
+const _TreeItem = require("../TreeItem/TreeItem");
+const FlatTreeItem = _TreeItem.TreeItem;

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/FlatTreeItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTreeItem/FlatTreeItem.tsx"],"sourcesContent":["import { FlatTreeItemProps } from './FlatTreeItem.types';\nimport { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { TreeItem } from '../TreeItem/TreeItem';\n\n/**\n * The `FlatTreeItem` component represents a single item in a flat tree.\n */\nexport const FlatTreeItem: ForwardRefComponent<FlatTreeItemProps> = TreeItem as ForwardRefComponent<FlatTreeItemProps>;\n"],"names":["TreeItem","FlatTreeItem"],"mappings":";;;;;;;;;;0BAEyB,uBAAuB;AAKzC,MAAMC,eAAuDD,kBAAAA,CAAmD"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/FlatTreeItem.types.js

@@ -0,0 +1,6 @@
+/**
+ * FlatTreeItem Props
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/FlatTreeItem.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTreeItem/FlatTreeItem.types.ts"],"sourcesContent":["import type { TreeItemProps, TreeItemValue } from '../TreeItem/TreeItem.types';\n\n/**\n * FlatTreeItem Props\n */\nexport type FlatTreeItemProps = TreeItemProps & {\n  value: TreeItemValue;\n  'aria-level': number;\n  'aria-setsize': number;\n  'aria-posinset': number;\n};\n"],"names":[],"mappings":"AAEA;;CAEC,GACD,WAKE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlatTreeItem", {
+    enumerable: true,
+    get: function() {
+        return _FlatTreeItem.FlatTreeItem;
+    }
+});
+const _FlatTreeItem = require("./FlatTreeItem");

node_modules/@fluentui/react-tree/lib-commonjs/components/FlatTreeItem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/FlatTreeItem/index.ts"],"sourcesContent":["export { FlatTreeItem } from './FlatTreeItem';\nexport type { FlatTreeItemProps } from './FlatTreeItem.types';\n"],"names":["FlatTreeItem"],"mappings":";;;;;;;eAASA,0BAAY;;;8BAAQ,iBAAiB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/Tree.js

@@ -0,0 +1,26 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "Tree", {
+    enumerable: true,
+    get: function() {
+        return Tree;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTree = require("./useTree");
+const _useTreeContextValues = require("./useTreeContextValues");
+const _useTreeStylesstyles = require("./useTreeStyles.styles");
+const _renderTree = require("./renderTree");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const Tree = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTree.useTree_unstable)(props, ref);
+    const contextValues = (0, _useTreeContextValues.useTreeContextValues_unstable)(state);
+    (0, _useTreeStylesstyles.useTreeStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTreeStyles_unstable')(state);
+    return (0, _renderTree.renderTree_unstable)(state, contextValues);
+});
+Tree.displayName = 'Tree';

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/Tree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/Tree.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useTree_unstable } from './useTree';\nimport type { TreeProps } from './Tree.types';\nimport { useTreeContextValues_unstable } from './useTreeContextValues';\nimport { useTreeStyles_unstable } from './useTreeStyles.styles';\nimport { renderTree_unstable } from './renderTree';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * The `Tree` component renders nested items in a hierarchical structure.\n * Use it with `TreeItem` component and layouts components `TreeItemLayout` or `TreeItemPersonaLayout`.\n */\nexport const Tree: ForwardRefComponent<TreeProps> = React.forwardRef((props, ref) => {\n  const state = useTree_unstable(props, ref);\n  const contextValues = useTreeContextValues_unstable(state);\n  useTreeStyles_unstable(state);\n  useCustomStyleHook_unstable('useTreeStyles_unstable')(state);\n\n  return renderTree_unstable(state, contextValues);\n});\n\nTree.displayName = 'Tree';\n"],"names":["React","useTree_unstable","useTreeContextValues_unstable","useTreeStyles_unstable","renderTree_unstable","useCustomStyleHook_unstable","Tree","forwardRef","props","ref","state","contextValues","displayName"],"mappings":"AAAA;;;;;;;;;;;;iEAEuB,QAAQ;yBAEE,YAAY;sCAEC,yBAAyB;qCAChC,yBAAyB;4BAC5B,eAAe;qCACP,kCAAkC;AAMvE,MAAMM,OAAAA,WAAAA,GAAuCN,OAAMO,UAAU,CAAC,CAACC,OAAOC;IAC3E,MAAMC,YAAQT,yBAAAA,EAAiBO,OAAOC;IACtC,MAAME,oBAAgBT,mDAAAA,EAA8BQ;QACpDP,2CAAAA,EAAuBO;QACvBL,gDAAAA,EAA4B,0BAA0BK;IAEtD,WAAON,+BAAAA,EAAoBM,OAAOC;AACpC,GAAG;AAEHL,KAAKM,WAAW,GAAG"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/Tree.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering Tree
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    Tree: function() {
+        return _Tree.Tree;
+    },
+    renderTree_unstable: function() {
+        return _renderTree.renderTree_unstable;
+    },
+    treeClassNames: function() {
+        return _useTreeStylesstyles.treeClassNames;
+    },
+    useTreeContextValues_unstable: function() {
+        return _useTreeContextValues.useTreeContextValues_unstable;
+    },
+    useTreeStyles_unstable: function() {
+        return _useTreeStylesstyles.useTreeStyles_unstable;
+    },
+    useTree_unstable: function() {
+        return _useTree.useTree_unstable;
+    }
+});
+const _Tree = require("./Tree");
+const _useTree = require("./useTree");
+const _useTreeContextValues = require("./useTreeContextValues");
+const _useTreeStylesstyles = require("./useTreeStyles.styles");
+const _renderTree = require("./renderTree");

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/index.ts"],"sourcesContent":["export { Tree } from './Tree';\nexport type {\n  TreeCheckedChangeData,\n  TreeCheckedChangeEvent,\n  TreeContextValues,\n  TreeNavigationData_unstable,\n  TreeNavigationEvent_unstable,\n  TreeOpenChangeData,\n  TreeOpenChangeEvent,\n  TreeProps,\n  TreeSelectionValue,\n  TreeSlots,\n  TreeState,\n  TreeNavigationMode,\n  TreeNavigationDataParam,\n} from './Tree.types';\nexport { useTree_unstable } from './useTree';\nexport { useTreeContextValues_unstable } from './useTreeContextValues';\nexport { treeClassNames, useTreeStyles_unstable } from './useTreeStyles.styles';\nexport { renderTree_unstable } from './renderTree';\n"],"names":["Tree","useTree_unstable","useTreeContextValues_unstable","treeClassNames","useTreeStyles_unstable","renderTree_unstable"],"mappings":";;;;;;;;;;;;eAASA,UAAI;;;eAmBJK,+BAAmB;;;eADnBF,mCAAc;;;eADdD,mDAA6B;;;eACbE,2CAAsB;;;eAFtCH,yBAAgB;;;sBAhBJ,SAAS;yBAgBG,YAAY;sCACC,yBAAyB;qCAChB,yBAAyB;4BAC5C,eAAe"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/renderTree.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTree_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTree_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _TreeProvider = require("../TreeProvider");
+const renderTree_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(_TreeProvider.TreeProvider, {
+        value: contextValues.tree,
+        children: state.collapseMotion ? /*#__PURE__*/ (0, _jsxruntime.jsx)(state.collapseMotion, {
+            children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {})
+        }) : /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {})
+    });
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/renderTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/renderTree.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { JSXElement } from '@fluentui/react-utilities';\nimport type { TreeContextValues, TreeSlots, TreeState } from '../Tree/Tree.types';\nimport { TreeProvider } from '../TreeProvider';\n\nexport const renderTree_unstable = (state: TreeState, contextValues: TreeContextValues): JSXElement => {\n  assertSlots<TreeSlots>(state);\n  return (\n    <TreeProvider value={contextValues.tree}>\n      {state.collapseMotion ? (\n        <state.collapseMotion>\n          <state.root />\n        </state.collapseMotion>\n      ) : (\n        <state.root />\n      )}\n    </TreeProvider>\n  );\n};\n"],"names":["assertSlots","TreeProvider","renderTree_unstable","state","contextValues","value","tree","collapseMotion","root"],"mappings":";;;;+BAOaE;;;;;;4BANb,gDAAiD;gCACrB,4BAA4B;8BAG3B,kBAAkB;AAExC,4BAA4B,CAACC,OAAkBC;QACpDJ,2BAAAA,EAAuBG;IACvB,OAAA,WAAA,OACE,eAAA,EAACF,0BAAAA,EAAAA;QAAaI,OAAOD,cAAcE,IAAI;kBACpCH,MAAMI,cAAc,GAAA,WAAA,OACnB,eAAA,EAACJ,MAAMI,cAAc,EAAA;sBACnB,WAAA,OAAA,eAAA,EAACJ,MAAMK,IAAI,EAAA,CAAA;+BAGb,eAAA,EAACL,MAAMK,IAAI,EAAA,CAAA;;AAInB,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useNestedControllableCheckedItems.js

@@ -0,0 +1,42 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    createNextNestedCheckedItems: function() {
+        return createNextNestedCheckedItems;
+    },
+    useNestedCheckedItems: function() {
+        return useNestedCheckedItems;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _ImmutableMap = require("../../utils/ImmutableMap");
+const _createCheckedItems = require("../../utils/createCheckedItems");
+function useNestedCheckedItems(props) {
+    return _react.useMemo(()=>(0, _createCheckedItems.createCheckedItems)(props.checkedItems), [
+        props.checkedItems
+    ]);
+}
+function createNextNestedCheckedItems(data, previousCheckedItems) {
+    if (data.selectionMode === 'single') {
+        return _ImmutableMap.ImmutableMap.from([
+            [
+                data.value,
+                data.checked
+            ]
+        ]);
+    }
+    if (data.selectionMode === 'multiselect') {
+        return previousCheckedItems.set(data.value, data.checked);
+    }
+    return previousCheckedItems;
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useNestedControllableCheckedItems.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/useNestedControllableCheckedItems.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport type { TreeCheckedChangeData, TreeProps } from './Tree.types';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nimport { TreeItemValue } from '../TreeItem/TreeItem.types';\n\nexport function useNestedCheckedItems(\n  props: Pick<TreeProps, 'checkedItems'>,\n): ImmutableMap<TreeItemValue, 'mixed' | boolean> {\n  return React.useMemo(() => createCheckedItems(props.checkedItems), [props.checkedItems]);\n}\n\nexport function createNextNestedCheckedItems(\n  data: Pick<TreeCheckedChangeData, 'selectionMode' | 'value' | 'checked'>,\n  previousCheckedItems: ImmutableMap<TreeItemValue, 'mixed' | boolean>,\n): ImmutableMap<TreeItemValue, 'mixed' | boolean> {\n  if (data.selectionMode === 'single') {\n    return ImmutableMap.from([[data.value, data.checked]]);\n  }\n  if (data.selectionMode === 'multiselect') {\n    return previousCheckedItems.set(data.value, data.checked);\n  }\n  return previousCheckedItems;\n}\n"],"names":["React","ImmutableMap","createCheckedItems","useNestedCheckedItems","props","useMemo","checkedItems","createNextNestedCheckedItems","data","previousCheckedItems","selectionMode","from","value","checked","set"],"mappings":"AAAA;;;;;;;;;;;;gCAcgBO;eAAAA;;yBANAJ;;;;;iEANO,QAAQ;8BAEF,2BAA2B;oCACrB,iCAAiC;AAG7D,SAASA,sBACdC,KAAsC;IAEtC,OAAOJ,OAAMK,OAAO,CAAC,QAAMH,sCAAAA,EAAmBE,MAAME,YAAY,GAAG;QAACF,MAAME,YAAY;KAAC;AACzF;AAEO,sCACLE,IAAwE,EACxEC,oBAAoE;IAEpE,IAAID,KAAKE,aAAa,KAAK,UAAU;QACnC,OAAOT,0BAAAA,CAAaU,IAAI,CAAC;YAAC;gBAACH,KAAKI,KAAK;gBAAEJ,KAAKK,OAAO;aAAC;SAAC;IACvD;IACA,IAAIL,KAAKE,aAAa,KAAK,eAAe;QACxC,OAAOD,qBAAqBK,GAAG,CAACN,KAAKI,KAAK,EAAEJ,KAAKK,OAAO;IAC1D;IACA,OAAOJ;AACT"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTree.js

@@ -0,0 +1,85 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTree_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTree_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _useControllableOpenItems = require("../../hooks/useControllableOpenItems");
+const _useNestedControllableCheckedItems = require("./useNestedControllableCheckedItems");
+const _subtreeContext = require("../../contexts/subtreeContext");
+const _useRootTree = require("../../hooks/useRootTree");
+const _useSubtree = require("../../hooks/useSubtree");
+const _useTreeNavigation = require("../../hooks/useTreeNavigation");
+const _treeContext = require("../../contexts/treeContext");
+const _ImmutableSet = require("../../utils/ImmutableSet");
+const _ImmutableMap = require("../../utils/ImmutableMap");
+const useTree_unstable = (props, ref)=>{
+    'use no memo';
+    const isRoot = _react.useContext(_subtreeContext.SubtreeContext) === undefined;
+    // as level is static, this doesn't break rule of hooks
+    // and if this becomes an issue later on, this can be easily converted
+    // eslint-disable-next-line react-hooks/rules-of-hooks
+    return isRoot ? useNestedRootTree(props, ref) : useNestedSubtree(props, ref);
+};
+function useNestedRootTree(props, ref) {
+    'use no memo';
+    const [openItems, setOpenItems] = (0, _useControllableOpenItems.useControllableOpenItems)(props);
+    const checkedItems = (0, _useNestedControllableCheckedItems.useNestedCheckedItems)(props);
+    const navigation = (0, _useTreeNavigation.useTreeNavigation)(props.navigationMode);
+    return Object.assign((0, _useRootTree.useRootTree)({
+        ...props,
+        openItems,
+        checkedItems,
+        onOpenChange: (0, _reactutilities.useEventCallback)((event, data)=>{
+            var _props_onOpenChange;
+            const nextOpenItems = (0, _useControllableOpenItems.createNextOpenItems)(data, openItems);
+            (_props_onOpenChange = props.onOpenChange) === null || _props_onOpenChange === void 0 ? void 0 : _props_onOpenChange.call(props, event, {
+                ...data,
+                openItems: _ImmutableSet.ImmutableSet.dangerouslyGetInternalSet(nextOpenItems)
+            });
+            setOpenItems(nextOpenItems);
+        }),
+        onNavigation: (0, _reactutilities.useEventCallback)((event, data)=>{
+            var _props_onNavigation;
+            (_props_onNavigation = props.onNavigation) === null || _props_onNavigation === void 0 ? void 0 : _props_onNavigation.call(props, event, data);
+            if (!event.isDefaultPrevented()) {
+                navigation.navigate(data, {
+                    preventScroll: data.isScrollPrevented()
+                });
+            }
+        }),
+        onCheckedChange: (0, _reactutilities.useEventCallback)((event, data)=>{
+            var _props_onCheckedChange;
+            const nextCheckedItems = (0, _useNestedControllableCheckedItems.createNextNestedCheckedItems)(data, checkedItems);
+            (_props_onCheckedChange = props.onCheckedChange) === null || _props_onCheckedChange === void 0 ? void 0 : _props_onCheckedChange.call(props, event, {
+                ...data,
+                checkedItems: _ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(nextCheckedItems)
+            });
+        })
+    }, (0, _reactutilities.useMergedRefs)(ref, navigation.treeRef)), {
+        treeType: 'nested',
+        forceUpdateRovingTabIndex: navigation.forceUpdateRovingTabIndex
+    });
+}
+function useNestedSubtree(props, ref) {
+    'use no memo';
+    if (process.env.NODE_ENV === 'development') {
+        // this doesn't break rule of hooks, as environment is a static value
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const treeType = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.treeType);
+        if (treeType === 'flat') {
+            throw new Error(`@fluentui/react-tree [useTree]:
+Subtrees are not allowed in a FlatTree!
+You cannot use a <Tree> component inside of a <FlatTree> component!`);
+        }
+    }
+    return (0, _useSubtree.useSubtree)(props, ref);
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeContextValues.js

@@ -0,0 +1,48 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeContextValues_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+function useTreeContextValues_unstable(state) {
+    'use no memo';
+    if (state.contextType === 'root') {
+        const { openItems, level, contextType, treeType, checkedItems, selectionMode, navigationMode, appearance, size, requestTreeResponse, forceUpdateRovingTabIndex } = state;
+        /**
+     * This context is created with "@fluentui/react-context-selector",
+     * there is no sense to memoize it
+     */ const tree = {
+            treeType,
+            size,
+            openItems,
+            appearance,
+            checkedItems,
+            selectionMode,
+            navigationMode,
+            contextType,
+            level,
+            requestTreeResponse,
+            forceUpdateRovingTabIndex
+        };
+        return {
+            tree
+        };
+    }
+    return {
+        // contextType is statically determined by the context
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        tree: _react.useMemo(()=>({
+                level: state.level,
+                contextType: 'subtree'
+            }), [
+            state.level
+        ])
+    };
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/useTreeContextValues.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { TreeContextValue } from '../../contexts';\nimport { TreeContextValues, TreeState } from './Tree.types';\n\nexport function useTreeContextValues_unstable(state: TreeState): TreeContextValues {\n  'use no memo';\n\n  if (state.contextType === 'root') {\n    const {\n      openItems,\n      level,\n      contextType,\n      treeType,\n      checkedItems,\n      selectionMode,\n      navigationMode,\n      appearance,\n      size,\n      requestTreeResponse,\n      forceUpdateRovingTabIndex,\n    } = state;\n    /**\n     * This context is created with \"@fluentui/react-context-selector\",\n     * there is no sense to memoize it\n     */\n    const tree: TreeContextValue = {\n      treeType,\n      size,\n      openItems,\n      appearance,\n      checkedItems,\n      selectionMode,\n      navigationMode,\n      contextType,\n      level,\n      requestTreeResponse,\n      forceUpdateRovingTabIndex,\n    };\n\n    return { tree };\n  }\n  return {\n    // contextType is statically determined by the context\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    tree: React.useMemo(() => ({ level: state.level, contextType: 'subtree' }), [state.level]),\n  };\n}\n"],"names":["React","useTreeContextValues_unstable","state","contextType","openItems","level","treeType","checkedItems","selectionMode","navigationMode","appearance","size","requestTreeResponse","forceUpdateRovingTabIndex","tree","useMemo"],"mappings":"AAAA;;;;;+BAMgBC;;;;;;;iEAJO,QAAQ;AAIxB,uCAAuCC,KAAgB;IAC5D;IAEA,IAAIA,MAAMC,WAAW,KAAK,QAAQ;QAChC,MAAM,EACJC,SAAS,EACTC,KAAK,EACLF,WAAW,EACXG,QAAQ,EACRC,YAAY,EACZC,aAAa,EACbC,cAAc,EACdC,UAAU,EACVC,IAAI,EACJC,mBAAmB,EACnBC,yBAAyB,EAC1B,GAAGX;QACJ;;;KAGC,GACD,MAAMY,OAAyB;YAC7BR;YACAK;YACAP;YACAM;YACAH;YACAC;YACAC;YACAN;YACAE;YACAO;YACAC;QACF;QAEA,OAAO;YAAEC;QAAK;IAChB;IACA,OAAO;QACL,sDAAsD;QACtD,sDAAsD;QACtDA,MAAMd,OAAMe,OAAO,CAAC,IAAO,CAAA;gBAAEV,OAAOH,MAAMG,KAAK;gBAAEF,aAAa;aAAU,CAAA,EAAI;YAACD,MAAMG,KAAK;SAAC;IAC3F;AACF"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeStyles.styles.js

@@ -0,0 +1,43 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeClassNames: function() {
+        return treeClassNames;
+    },
+    useTreeStyles_unstable: function() {
+        return useTreeStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const treeClassNames = {
+    root: 'fui-Tree'
+};
+const useBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rnv2ez3", null, [
+    ".rnv2ez3{display:flex;flex-direction:column;row-gap:var(--spacingVerticalXXS);}"
+]);
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    subtree: {
+        z8tnut: "fclwglc"
+    }
+}, {
+    d: [
+        ".fclwglc{padding-top:var(--spacingVerticalXXS);}"
+    ]
+});
+const useTreeStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    const styles = useStyles();
+    const isSubTree = state.level > 1;
+    state.root.className = (0, _react.mergeClasses)(treeClassNames.root, baseStyles, isSubTree && styles.subtree, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useTreeStyles.styles.js"],"sourcesContent":["'use client';\nimport { makeResetStyles, makeStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const treeClassNames = {\n    root: 'fui-Tree'\n};\nconst useBaseStyles = makeResetStyles({\n    display: 'flex',\n    flexDirection: 'column',\n    rowGap: tokens.spacingVerticalXXS\n});\nconst useStyles = makeStyles({\n    subtree: {\n        paddingTop: tokens.spacingVerticalXXS\n    }\n});\nexport const useTreeStyles_unstable = (state)=>{\n    'use no memo';\n    const baseStyles = useBaseStyles();\n    const styles = useStyles();\n    const isSubTree = state.level > 1;\n    state.root.className = mergeClasses(treeClassNames.root, baseStyles, isSubTree && styles.subtree, state.root.className);\n    return state;\n};\n"],"names":["__resetStyles","__styles","mergeClasses","tokens","treeClassNames","root","useBaseStyles","useStyles","subtree","z8tnut","d","useTreeStyles_unstable","state","baseStyles","styles","isSubTree","level","className"],"mappings":"AAAA,YAAY;;;;;;;;;;;;IAGCI,cAAc;;;0BAaQ;eAAtBO;;;uBAf6C,gBAAgB;AAEnE,uBAAuB;IAC1BN,IAAI,EAAE;AACV,CAAC;AACD,MAAMC,aAAa,GAAA,WAAA,OAAGN,oBAAA,EAAA,WAAA,MAAA;IAAA;CAIrB,CAAC;AACF,MAAMO,SAAS,GAAA,WAAA,OAAGN,eAAA,EAAA;IAAAO,OAAA,EAAA;QAAAC,MAAA,EAAA;IAAA;AAAA,GAAA;IAAAC,CAAA,EAAA;QAAA;KAAA;AAAA,CAIjB,CAAC;AACK,gCAAgCE,KAAK,IAAG;IAC3C,aAAa;IACb,MAAMC,UAAU,GAAGP,aAAa,CAAC,CAAC;IAClC,MAAMQ,MAAM,GAAGP,SAAS,CAAC,CAAC;IAC1B,MAAMQ,SAAS,GAAGH,KAAK,CAACI,KAAK,GAAG,CAAC;IACjCJ,KAAK,CAACP,IAAI,CAACY,SAAS,OAAGf,mBAAY,EAACE,cAAc,CAACC,IAAI,EAAEQ,UAAU,EAAEE,SAAS,IAAID,MAAM,CAACN,OAAO,EAAEI,KAAK,CAACP,IAAI,CAACY,SAAS,CAAC;IACvH,OAAOL,KAAK;AAChB,CAAC"}

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeStyles.styles.raw.js

@@ -0,0 +1,42 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeClassNames: function() {
+        return treeClassNames;
+    },
+    useTreeStyles_unstable: function() {
+        return useTreeStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reacttheme = require("@fluentui/react-theme");
+const treeClassNames = {
+    root: 'fui-Tree'
+};
+const useBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    flexDirection: 'column',
+    rowGap: _reacttheme.tokens.spacingVerticalXXS
+});
+const useStyles = (0, _react.makeStyles)({
+    subtree: {
+        paddingTop: _reacttheme.tokens.spacingVerticalXXS
+    }
+});
+const useTreeStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    const styles = useStyles();
+    const isSubTree = state.level > 1;
+    state.root.className = (0, _react.mergeClasses)(treeClassNames.root, baseStyles, isSubTree && styles.subtree, state.root.className);
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/Tree/useTreeStyles.styles.raw.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/Tree/useTreeStyles.styles.ts"],"sourcesContent":["'use client';\n\nimport { makeResetStyles, makeStyles, mergeClasses } from '@griffel/react';\nimport type { TreeSlots, TreeState } from './Tree.types';\nimport type { SlotClassNames } from '@fluentui/react-utilities';\nimport { tokens } from '@fluentui/react-theme';\n\nexport const treeClassNames: SlotClassNames<Omit<TreeSlots, 'collapseMotion'>> = {\n  root: 'fui-Tree',\n};\n\nconst useBaseStyles = makeResetStyles({\n  display: 'flex',\n  flexDirection: 'column',\n  rowGap: tokens.spacingVerticalXXS,\n});\n\nconst useStyles = makeStyles({\n  subtree: {\n    paddingTop: tokens.spacingVerticalXXS,\n  },\n});\n\nexport const useTreeStyles_unstable = (state: TreeState): TreeState => {\n  'use no memo';\n\n  const baseStyles = useBaseStyles();\n  const styles = useStyles();\n  const isSubTree = state.level > 1;\n\n  state.root.className = mergeClasses(\n    treeClassNames.root,\n    baseStyles,\n    isSubTree && styles.subtree,\n    state.root.className,\n  );\n  return state;\n};\n"],"names":["makeResetStyles","makeStyles","mergeClasses","tokens","treeClassNames","root","useBaseStyles","display","flexDirection","rowGap","spacingVerticalXXS","useStyles","subtree","paddingTop","useTreeStyles_unstable","state","baseStyles","styles","isSubTree","level","className"],"mappings":"AAAA;;;;;;;;;;;;IAOaI,cAAAA;;;0BAgBAU;eAAAA;;;uBArB6C,iBAAiB;4BAGpD,wBAAwB;AAExC,uBAA0E;IAC/ET,MAAM;AACR,EAAE;AAEF,MAAMC,oBAAgBN,sBAAAA,EAAgB;IACpCO,SAAS;IACTC,eAAe;IACfC,QAAQN,kBAAAA,CAAOO,kBAAkB;AACnC;AAEA,MAAMC,gBAAYV,iBAAAA,EAAW;IAC3BW,SAAS;QACPC,YAAYV,kBAAAA,CAAOO,kBAAkB;IACvC;AACF;AAEO,+BAA+B,CAACK;IACrC;IAEA,MAAMC,aAAaV;IACnB,MAAMW,SAASN;IACf,MAAMO,YAAYH,MAAMI,KAAK,GAAG;IAEhCJ,MAAMV,IAAI,CAACe,SAAS,OAAGlB,mBAAAA,EACrBE,eAAeC,IAAI,EACnBW,YACAE,aAAaD,OAAOL,OAAO,EAC3BG,MAAMV,IAAI,CAACe,SAAS;IAEtB,OAAOL;AACT,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/TreeItem.js

@@ -0,0 +1,26 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TreeItem", {
+    enumerable: true,
+    get: function() {
+        return TreeItem;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTreeItem = require("./useTreeItem");
+const _renderTreeItem = require("./renderTreeItem");
+const _useTreeItemStylesstyles = require("./useTreeItemStyles.styles");
+const _useTreeItemContextValues = require("./useTreeItemContextValues");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const TreeItem = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTreeItem.useTreeItem_unstable)(props, ref);
+    (0, _useTreeItemStylesstyles.useTreeItemStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTreeItemStyles_unstable')(state);
+    const contextValues = (0, _useTreeItemContextValues.useTreeItemContextValues_unstable)(state);
+    return (0, _renderTreeItem.renderTreeItem_unstable)(state, contextValues);
+});
+TreeItem.displayName = 'TreeItem';

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/TreeItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItem/TreeItem.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTreeItem_unstable } from './useTreeItem';\nimport { renderTreeItem_unstable } from './renderTreeItem';\nimport { useTreeItemStyles_unstable } from './useTreeItemStyles.styles';\nimport type { TreeItemProps } from './TreeItem.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useTreeItemContextValues_unstable } from './useTreeItemContextValues';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * The `TreeItem` component represents a single item in a tree.\n * It expects a certain order of children to work properly: the first child should be the node itself,\n * and the second child should be a nested subtree in the form of another Tree component or a standalone TreeItem.\n * This order follows the same order as document traversal for the TreeWalker API in JavaScript:\n * https://developer.mozilla.org/en-US/docs/Web/API/TreeWalker.\n * The content and layout of a TreeItem can be defined using the TreeItemLayout or TreeItemPersonaLayout component,\n * which should be used as a direct child of TreeItem.\n *\n * When a TreeItem has nested child subtree, an expand/collapse control is displayed,\n * allowing the user to show or hide the children.\n */\nexport const TreeItem: ForwardRefComponent<TreeItemProps> = React.forwardRef((props, ref) => {\n  const state = useTreeItem_unstable(props, ref);\n\n  useTreeItemStyles_unstable(state);\n  useCustomStyleHook_unstable('useTreeItemStyles_unstable')(state);\n\n  const contextValues = useTreeItemContextValues_unstable(state);\n  return renderTreeItem_unstable(state, contextValues);\n});\n\nTreeItem.displayName = 'TreeItem';\n"],"names":["React","useTreeItem_unstable","renderTreeItem_unstable","useTreeItemStyles_unstable","useTreeItemContextValues_unstable","useCustomStyleHook_unstable","TreeItem","forwardRef","props","ref","state","contextValues","displayName"],"mappings":"AAAA;;;;;;;;;;;;iEAEuB,QAAQ;6BACM,gBAAgB;gCACb,mBAAmB;yCAChB,6BAA6B;0CAGtB,6BAA6B;qCACnC,kCAAkC;AAcvE,MAAMM,WAAAA,WAAAA,GAA+CN,OAAMO,UAAU,CAAC,CAACC,OAAOC;IACnF,MAAMC,YAAQT,iCAAAA,EAAqBO,OAAOC;QAE1CN,mDAAAA,EAA2BO;QAC3BL,gDAAAA,EAA4B,8BAA8BK;IAE1D,MAAMC,oBAAgBP,2DAAAA,EAAkCM;IACxD,WAAOR,uCAAAA,EAAwBQ,OAAOC;AACxC,GAAG;AAEHL,SAASM,WAAW,GAAG"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/TreeItem.types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/TreeItem.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItem/TreeItem.types.ts"],"sourcesContent":["import * as React from 'react';\nimport type { ArrowLeft, ArrowRight, Enter } from '@fluentui/keyboard-keys';\nimport type { ComponentProps, ComponentState, ExtractSlotProps, Slot } from '@fluentui/react-utilities';\nimport type { TreeItemContextValue } from '../../contexts';\nimport type { treeItemLevelToken } from '../../utils/tokens';\n\nexport type TreeItemCSSProperties = React.CSSProperties & { [treeItemLevelToken]?: string | number };\n\nexport type TreeItemType = 'leaf' | 'branch';\n\nexport type TreeItemSlots = {\n  root: Slot<ExtractSlotProps<Slot<'div'> & { style?: TreeItemCSSProperties }>>;\n};\n\nexport type TreeItemValue = string | number;\n\nexport type TreeItemContextValues = {\n  treeItem: TreeItemContextValue;\n};\n\nexport type TreeItemOpenChangeData = {\n  open: boolean;\n  value: TreeItemValue;\n  target: HTMLElement;\n} & (\n  | { event: React.MouseEvent<HTMLElement>; type: 'ExpandIconClick' }\n  | { event: React.MouseEvent<HTMLElement>; type: 'Click' }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof Enter }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowRight }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowLeft }\n);\n\nexport type TreeItemOpenChangeEvent = TreeItemOpenChangeData['event'];\n\n/**\n * TreeItem Props\n */\nexport type TreeItemProps = ComponentProps<Partial<TreeItemSlots>> & {\n  /**\n   * A tree item can be a leaf or a branch\n   */\n  itemType: TreeItemType;\n  /**\n   * A tree item should have a well defined value, in case one is not provided by the user by this prop\n   * one will be inferred internally.\n   */\n  value?: TreeItemValue;\n  /**\n   * Whether the tree item is in an open state\n   *\n   * This overrides the open value provided by the root tree,\n   * and ensure control of the visibility of the tree item per tree item.\n   *\n   * NOTE: controlling the open state of a tree item will not affect the open state of its children\n   */\n  open?: boolean;\n  // eslint-disable-next-line @nx/workspace-consistent-callback-type -- can't change type of existing callback\n  onOpenChange?: (e: TreeItemOpenChangeEvent, data: TreeItemOpenChangeData) => void;\n  /**\n   * This property is inferred through context on a nested tree, and required for a flat tree.\n   */\n  parentValue?: TreeItemValue;\n};\n\n/**\n * State used in rendering TreeItem\n */\nexport type TreeItemState = ComponentState<TreeItemSlots> &\n  TreeItemContextValue & {\n    level: number;\n    itemType: TreeItemType;\n  };\n"],"names":["React"],"mappings":";;;;;iEAAuB,QAAQ"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/index.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TreeItem: function() {
+        return _TreeItem.TreeItem;
+    },
+    renderTreeItem_unstable: function() {
+        return _renderTreeItem.renderTreeItem_unstable;
+    },
+    treeItemClassNames: function() {
+        return _useTreeItemStylesstyles.treeItemClassNames;
+    },
+    useTreeItemContextValues_unstable: function() {
+        return _useTreeItemContextValues.useTreeItemContextValues_unstable;
+    },
+    useTreeItemStyles_unstable: function() {
+        return _useTreeItemStylesstyles.useTreeItemStyles_unstable;
+    },
+    useTreeItem_unstable: function() {
+        return _useTreeItem.useTreeItem_unstable;
+    }
+});
+const _TreeItem = require("./TreeItem");
+const _renderTreeItem = require("./renderTreeItem");
+const _useTreeItem = require("./useTreeItem");
+const _useTreeItemStylesstyles = require("./useTreeItemStyles.styles");
+const _useTreeItemContextValues = require("./useTreeItemContextValues");

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItem/index.ts"],"sourcesContent":["export { TreeItem } from './TreeItem';\nexport type {\n  TreeItemCSSProperties,\n  TreeItemContextValues,\n  TreeItemOpenChangeData,\n  TreeItemOpenChangeEvent,\n  TreeItemProps,\n  TreeItemSlots,\n  TreeItemState,\n  TreeItemType,\n  TreeItemValue,\n} from './TreeItem.types';\nexport { renderTreeItem_unstable } from './renderTreeItem';\nexport { useTreeItem_unstable } from './useTreeItem';\nexport { treeItemClassNames, useTreeItemStyles_unstable } from './useTreeItemStyles.styles';\nexport { useTreeItemContextValues_unstable } from './useTreeItemContextValues';\n"],"names":["TreeItem","renderTreeItem_unstable","useTreeItem_unstable","treeItemClassNames","useTreeItemStyles_unstable","useTreeItemContextValues_unstable"],"mappings":";;;;;;;;;;;;eAASA,kBAAQ;;;eAYRC,uCAAuB;;;eAEvBE,2CAAkB;;;eAClBE,2DAAiC;;;eADbD,mDAA0B;;;eAD9CF,iCAAoB;;;0BAbJ,aAAa;gCAYE,mBAAmB;6BACtB,gBAAgB;yCACU,6BAA6B;0CAC1C,6BAA6B"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/renderTreeItem.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTreeItem_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTreeItem_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _contexts = require("../../contexts");
+const renderTreeItem_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsx)(state.root, {
+        children: /*#__PURE__*/ (0, _jsxruntime.jsx)(_contexts.TreeItemProvider, {
+            value: contextValues.treeItem,
+            children: state.root.children
+        })
+    });
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/renderTreeItem.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItem/renderTreeItem.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { JSXElement } from '@fluentui/react-utilities';\nimport type { TreeItemState, TreeItemContextValues, TreeItemSlots } from './TreeItem.types';\nimport { TreeItemProvider } from '../../contexts';\n\n/**\n * Render the final JSX of TreeItem\n */\nexport const renderTreeItem_unstable = (state: TreeItemState, contextValues: TreeItemContextValues): JSXElement => {\n  assertSlots<TreeItemSlots>(state);\n\n  return (\n    <state.root>\n      <TreeItemProvider value={contextValues.treeItem}>{state.root.children}</TreeItemProvider>\n    </state.root>\n  );\n};\n"],"names":["assertSlots","TreeItemProvider","renderTreeItem_unstable","state","contextValues","root","value","treeItem","children"],"mappings":";;;;+BAUaE;;;;;;4BATb,gDAAiD;gCACrB,4BAA4B;0BAGvB,iBAAiB;AAK3C,gCAAgC,CAACC,OAAsBC;QAC5DJ,2BAAAA,EAA2BG;IAE3B,OAAA,WAAA,OACE,eAAA,EAACA,MAAME,IAAI,EAAA;kBACT,WAAA,OAAA,eAAA,EAACJ,0BAAAA,EAAAA;YAAiBK,OAAOF,cAAcG,QAAQ;sBAAGJ,MAAME,IAAI,CAACG,QAAQ;;;AAG3E,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItem.js

@@ -0,0 +1,363 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeItem_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeItem_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactdom = /*#__PURE__*/ _interop_require_wildcard._(require("react-dom"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _keyboardkeys = require("@fluentui/keyboard-keys");
+const _tokens = require("../../utils/tokens");
+const _contexts = require("../../contexts");
+const _getTreeItemValueFromElement = require("../../utils/getTreeItemValueFromElement");
+const _reactcontextselector = require("@fluentui/react-context-selector");
+const _Tree = require("../../Tree");
+function useTreeItem_unstable(props, ref) {
+    'use no memo';
+    const treeType = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.treeType);
+    if (treeType === 'flat') {
+        warnIfNoProperPropsFlatTreeItem(props);
+    }
+    const requestTreeResponse = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.requestTreeResponse);
+    const navigationMode = (0, _contexts.useTreeContext_unstable)((ctx)=>{
+        var _ctx_navigationMode;
+        return (_ctx_navigationMode = ctx.navigationMode) !== null && _ctx_navigationMode !== void 0 ? _ctx_navigationMode : 'tree';
+    });
+    const forceUpdateRovingTabIndex = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.forceUpdateRovingTabIndex);
+    const { level: contextLevel } = (0, _contexts.useSubtreeContext_unstable)();
+    const parentValue = (0, _contexts.useTreeItemContext_unstable)((ctx)=>{
+        var _props_parentValue;
+        return (_props_parentValue = props.parentValue) !== null && _props_parentValue !== void 0 ? _props_parentValue : ctx.value;
+    });
+    // note, if the value is not externally provided,
+    // then selection and expansion will not work properly
+    const internalValue = (0, _reactutilities.useId)('fuiTreeItemValue-');
+    var _props_value;
+    const value = (_props_value = props.value) !== null && _props_value !== void 0 ? _props_value : internalValue;
+    const { onClick, onKeyDown, onChange, as = 'div', itemType = 'leaf', 'aria-level': level = contextLevel, 'aria-selected': ariaSelected, 'aria-expanded': ariaExpanded, ...rest } = props;
+    const actionsRef = _react.useRef(null);
+    const expandIconRef = _react.useRef(null);
+    const layoutRef = _react.useRef(null);
+    const subtreeRef = _react.useRef(null);
+    const selectionRef = _react.useRef(null);
+    const treeItemRef = _react.useRef(null);
+    if (process.env.NODE_ENV !== 'production') {
+        // This is acceptable since the NODE_ENV will not change during runtime
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const hasTreeContext = (0, _reactcontextselector.useHasParentContext)(_contexts.TreeContext);
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        _react.useEffect(()=>{
+            var _treeItemRef_current;
+            if (hasTreeContext) {
+                return;
+            }
+            if ((_treeItemRef_current = treeItemRef.current) === null || _treeItemRef_current === void 0 ? void 0 : _treeItemRef_current.querySelector(`.${_Tree.treeClassNames.root}`)) {
+                // eslint-disable-next-line no-console
+                console.error(`@fluentui/react-tree [useTreeItem]:
+<TreeItem> should be declared inside a <Tree> component.`);
+            }
+        }, [
+            hasTreeContext
+        ]);
+    }
+    _react.useEffect(()=>{
+        // When the tree item is mounted, we might need to update the roving tab index
+        // in edge cases where the tree is empty and then populated
+        forceUpdateRovingTabIndex === null || forceUpdateRovingTabIndex === void 0 ? void 0 : forceUpdateRovingTabIndex();
+        const treeItem = treeItemRef.current;
+        return ()=>{
+            // When the tree item is unmounted, we need to update the roving tab index
+            // if the tree item is the current tab indexed item
+            if (treeItem && treeItem.tabIndex === 0) {
+                forceUpdateRovingTabIndex === null || forceUpdateRovingTabIndex === void 0 ? void 0 : forceUpdateRovingTabIndex();
+            }
+        };
+    }, [
+        forceUpdateRovingTabIndex
+    ]);
+    const open = (0, _contexts.useTreeContext_unstable)((ctx)=>{
+        var _props_open;
+        return (_props_open = props.open) !== null && _props_open !== void 0 ? _props_open : ctx.openItems.has(value);
+    });
+    const getNextOpen = ()=>itemType === 'branch' ? !open : open;
+    const selectionMode = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.selectionMode);
+    const checked = (0, _contexts.useTreeContext_unstable)((ctx)=>{
+        var _ctx_checkedItems_get;
+        return (_ctx_checkedItems_get = ctx.checkedItems.get(value)) !== null && _ctx_checkedItems_get !== void 0 ? _ctx_checkedItems_get : false;
+    });
+    const handleClick = (0, _reactutilities.useEventCallback)((event)=>{
+        var _expandIconRef_current;
+        const isEventFromActions = ()=>actionsRef.current && (0, _reactutilities.elementContains)(actionsRef.current, event.target);
+        const isEventFromSubtree = ()=>subtreeRef.current && (0, _reactutilities.elementContains)(subtreeRef.current, event.target);
+        const isEventFromSelection = ()=>{
+            var _selectionRef_current;
+            return (_selectionRef_current = selectionRef.current) === null || _selectionRef_current === void 0 ? void 0 : _selectionRef_current.contains(event.target);
+        };
+        const isEventFromExpandIcon = (_expandIconRef_current = expandIconRef.current) === null || _expandIconRef_current === void 0 ? void 0 : _expandIconRef_current.contains(event.target);
+        if (isEventFromActions() || isEventFromSubtree() || isEventFromSelection()) {
+            return;
+        } else if (!isEventFromExpandIcon) {
+            onClick === null || onClick === void 0 ? void 0 : onClick(event);
+        }
+        if (event.isDefaultPrevented()) {
+            return;
+        }
+        _reactdom.unstable_batchedUpdates(()=>{
+            const data = {
+                event,
+                value,
+                open: getNextOpen(),
+                target: event.currentTarget,
+                type: isEventFromExpandIcon ? _tokens.treeDataTypes.ExpandIconClick : _tokens.treeDataTypes.Click
+            };
+            if (itemType !== 'leaf') {
+                var _props_onOpenChange;
+                (_props_onOpenChange = props.onOpenChange) === null || _props_onOpenChange === void 0 ? void 0 : _props_onOpenChange.call(props, event, data);
+                requestTreeResponse({
+                    ...data,
+                    itemType,
+                    requestType: 'open'
+                });
+            }
+            requestTreeResponse({
+                ...data,
+                itemType,
+                parentValue,
+                requestType: 'navigate',
+                type: _tokens.treeDataTypes.Click
+            });
+        });
+    });
+    const handleKeyDown = (0, _reactutilities.useEventCallback)((event)=>{
+        onKeyDown === null || onKeyDown === void 0 ? void 0 : onKeyDown(event);
+        if (event.isDefaultPrevented() || !treeItemRef.current) {
+            return;
+        }
+        const isEventFromTreeItem = event.currentTarget === event.target;
+        const isEventFromActions = actionsRef.current && actionsRef.current.contains(event.target);
+        switch(event.key){
+            case _keyboardkeys.Space:
+                {
+                    if (!isEventFromTreeItem) {
+                        return;
+                    }
+                    if (selectionMode !== 'none') {
+                        var _selectionRef_current;
+                        (_selectionRef_current = selectionRef.current) === null || _selectionRef_current === void 0 ? void 0 : _selectionRef_current.click();
+                        // Prevents the page from scrolling down when the spacebar is pressed
+                        event.preventDefault();
+                    }
+                    return;
+                }
+            case _tokens.treeDataTypes.Enter:
+                {
+                    if (!isEventFromTreeItem) {
+                        return;
+                    }
+                    return event.currentTarget.click();
+                }
+            case _tokens.treeDataTypes.End:
+            case _tokens.treeDataTypes.Home:
+            case _tokens.treeDataTypes.ArrowUp:
+                {
+                    if (!isEventFromTreeItem && !isEventFromActions) {
+                        return;
+                    }
+                    return requestTreeResponse({
+                        requestType: 'navigate',
+                        event,
+                        value,
+                        itemType,
+                        parentValue,
+                        type: event.key,
+                        target: event.currentTarget
+                    });
+                }
+            case _tokens.treeDataTypes.ArrowDown:
+                {
+                    if (!isEventFromTreeItem && !isEventFromActions) {
+                        return;
+                    }
+                    if (isEventFromActions && (!(0, _reactutilities.isHTMLElement)(event.target) || event.target.hasAttribute('aria-haspopup'))) {
+                        return;
+                    }
+                    return requestTreeResponse({
+                        requestType: 'navigate',
+                        event,
+                        value,
+                        itemType,
+                        parentValue,
+                        type: event.key,
+                        target: event.currentTarget
+                    });
+                }
+            case _tokens.treeDataTypes.ArrowLeft:
+                {
+                    // arrow left with alt key is reserved for history navigation
+                    if (event.altKey) {
+                        return;
+                    }
+                    const data = {
+                        value,
+                        event,
+                        open: getNextOpen(),
+                        type: event.key,
+                        itemType,
+                        parentValue,
+                        target: event.currentTarget
+                    };
+                    if (isEventFromActions && navigationMode === 'treegrid') {
+                        requestTreeResponse({
+                            ...data,
+                            requestType: 'navigate'
+                        });
+                        return;
+                    }
+                    if (!isEventFromTreeItem) {
+                        return;
+                    }
+                    // do not navigate to parent if the item is on the top level
+                    if (level === 1 && !open) {
+                        return;
+                    }
+                    if (open) {
+                        var _props_onOpenChange;
+                        (_props_onOpenChange = props.onOpenChange) === null || _props_onOpenChange === void 0 ? void 0 : _props_onOpenChange.call(props, event, data);
+                    }
+                    requestTreeResponse({
+                        ...data,
+                        requestType: open ? 'open' : 'navigate'
+                    });
+                    return;
+                }
+            case _tokens.treeDataTypes.ArrowRight:
+                {
+                    // Ignore keyboard events that do not originate from the current tree item.
+                    if (!isEventFromTreeItem) {
+                        return;
+                    }
+                    // arrow right with alt key is reserved for history navigation
+                    if (event.altKey) {
+                        return;
+                    }
+                    const data = {
+                        value,
+                        event,
+                        open: getNextOpen(),
+                        type: event.key,
+                        target: event.currentTarget
+                    };
+                    if (itemType === 'branch' && !open) {
+                        var _props_onOpenChange1;
+                        (_props_onOpenChange1 = props.onOpenChange) === null || _props_onOpenChange1 === void 0 ? void 0 : _props_onOpenChange1.call(props, event, data);
+                        requestTreeResponse({
+                            ...data,
+                            itemType,
+                            requestType: 'open'
+                        });
+                    } else {
+                        requestTreeResponse({
+                            ...data,
+                            itemType,
+                            parentValue,
+                            requestType: 'navigate'
+                        });
+                    }
+                    return;
+                }
+        }
+        // Ignore keyboard events that do not originate from the current tree item.
+        if (!isEventFromTreeItem) {
+            return;
+        }
+        const isTypeAheadCharacter = event.key.length === 1 && event.key.match(/\w/) && !event.altKey && !event.ctrlKey && !event.metaKey;
+        if (isTypeAheadCharacter) {
+            requestTreeResponse({
+                requestType: 'navigate',
+                event,
+                target: event.currentTarget,
+                value,
+                itemType,
+                type: _tokens.treeDataTypes.TypeAhead,
+                parentValue
+            });
+        }
+    });
+    const handleChange = (0, _reactutilities.useEventCallback)((event)=>{
+        onChange === null || onChange === void 0 ? void 0 : onChange(event);
+        if (event.isDefaultPrevented()) {
+            return;
+        }
+        const isEventFromSubtree = subtreeRef.current && (0, _reactutilities.elementContains)(subtreeRef.current, event.target);
+        if (isEventFromSubtree) {
+            return;
+        }
+        requestTreeResponse({
+            requestType: 'selection',
+            event,
+            value,
+            itemType,
+            type: 'Change',
+            target: event.currentTarget,
+            checked: checked === 'mixed' ? true : !checked
+        });
+    });
+    return {
+        value,
+        open,
+        checked,
+        subtreeRef,
+        layoutRef,
+        selectionRef,
+        expandIconRef,
+        treeItemRef,
+        actionsRef,
+        itemType,
+        level,
+        components: {
+            root: 'div'
+        },
+        // FIXME: this property is not necessary anymore, but as removing it would be a breaking change, we need to keep it as false
+        isAsideVisible: false,
+        // FIXME: this property is not necessary anymore, but as removing it would be a breaking change, we need to keep it as false
+        isActionsVisible: false,
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)(as, {
+            tabIndex: -1,
+            [_getTreeItemValueFromElement.dataTreeItemValueAttrName]: value,
+            role: 'treeitem',
+            ...rest,
+            ref: (0, _reactutilities.useMergedRefs)(ref, treeItemRef),
+            'aria-level': level,
+            'aria-checked': selectionMode === 'multiselect' ? checked : undefined,
+            'aria-selected': ariaSelected !== undefined ? ariaSelected : selectionMode === 'single' ? !!checked : undefined,
+            'aria-expanded': ariaExpanded !== undefined ? ariaExpanded : itemType === 'branch' ? open : undefined,
+            onClick: handleClick,
+            onKeyDown: handleKeyDown,
+            onChange: handleChange
+        }), {
+            elementType: 'div'
+        })
+    };
+}
+function warnIfNoProperPropsFlatTreeItem(props) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (props['aria-posinset'] === undefined || props['aria-setsize'] === undefined || props['aria-level'] === undefined || props.parentValue === undefined && props['aria-level'] !== 1) {
+            // eslint-disable-next-line no-console
+            console.error(`@fluentui/react-tree [${useTreeItem_unstable.name}]:
+A flat treeitem must have "aria-posinset", "aria-setsize", "aria-level"
+and "parentValue" (if "aria-level" > 1) to ensure a11y and navigation.
+
+- "aria-posinset": the position of this treeitem in the current level of the tree.
+- "aria-setsize": the number of siblings in this level of the tree.
+- "aria-level": the current level of the treeitem.
+- "parentValue": the "value" property of the parent item of this item.`);
+        }
+    }
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItemContextValues.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeItemContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeItemContextValues_unstable;
+    }
+});
+function useTreeItemContextValues_unstable(state) {
+    const { value, itemType, layoutRef, subtreeRef, open, expandIconRef, actionsRef, treeItemRef, isActionsVisible, isAsideVisible, selectionRef, checked } = state;
+    /**
+   * This context is created with "@fluentui/react-context-selector",
+   * there is no sense to memoize it
+   */ const treeItem = {
+        value,
+        checked,
+        itemType,
+        layoutRef,
+        subtreeRef,
+        open,
+        selectionRef,
+        isActionsVisible,
+        isAsideVisible,
+        actionsRef,
+        treeItemRef,
+        expandIconRef
+    };
+    return {
+        treeItem
+    };
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItemContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItem/useTreeItemContextValues.ts"],"sourcesContent":["import type { TreeItemContextValues, TreeItemState } from './TreeItem.types';\nimport type { TreeItemContextValue } from '../../contexts';\n\nexport function useTreeItemContextValues_unstable(state: TreeItemState): TreeItemContextValues {\n  const {\n    value,\n    itemType,\n    layoutRef,\n    subtreeRef,\n    open,\n    expandIconRef,\n    actionsRef,\n    treeItemRef,\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    isActionsVisible,\n    // eslint-disable-next-line @typescript-eslint/no-deprecated\n    isAsideVisible,\n    selectionRef,\n    checked,\n  } = state;\n\n  /**\n   * This context is created with \"@fluentui/react-context-selector\",\n   * there is no sense to memoize it\n   */\n  const treeItem: TreeItemContextValue = {\n    value,\n    checked,\n    itemType,\n    layoutRef,\n    subtreeRef,\n    open,\n    selectionRef,\n    isActionsVisible,\n    isAsideVisible,\n    actionsRef,\n    treeItemRef,\n    expandIconRef,\n  };\n\n  return { treeItem };\n}\n"],"names":["useTreeItemContextValues_unstable","state","value","itemType","layoutRef","subtreeRef","open","expandIconRef","actionsRef","treeItemRef","isActionsVisible","isAsideVisible","selectionRef","checked","treeItem"],"mappings":";;;;+BAGgBA;;;;;;AAAT,2CAA2CC,KAAoB;IACpE,MAAM,EACJC,KAAK,EACLC,QAAQ,EACRC,SAAS,EACTC,UAAU,EACVC,IAAI,EACJC,aAAa,EACbC,UAAU,EACVC,WAAW,EACX,AACAC,gBAAgB,EAEhBC,AADA,cACc,EACdC,YAAY,EACZC,OAAO,EACR,GAN6D,AAM1DZ,kBAJ0D;IAM9D;;;GAGC,GACD,MAAMa,WAAiC;QACrCZ;QACAW;QACAV;QACAC;QACAC;QACAC;QACAM;QACAF;QACAC;QACAH;QACAC;QACAF;IACF;IAEA,OAAO;QAAEO;IAAS;AACpB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItemStyles.styles.js

@@ -0,0 +1,89 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemClassNames: function() {
+        return treeItemClassNames;
+    },
+    useTreeItemStyles_unstable: function() {
+        return useTreeItemStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const treeItemClassNames = {
+    root: 'fui-TreeItem'
+};
+const useBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r15xhw3a", "r2f6k57", [
+    ".r15xhw3a{position:relative;cursor:pointer;display:flex;flex-direction:column;box-sizing:border-box;background-color:var(--colorSubtleBackground);color:var(--colorNeutralForeground2);padding-right:var(--spacingHorizontalNone);}",
+    ".r15xhw3a:focus{outline-style:none;}",
+    ".r15xhw3a:focus-visible{outline-style:none;}",
+    ".r15xhw3a[data-fui-focus-visible]>.fui-TreeItemLayout,.r15xhw3a[data-fui-focus-visible]>.fui-TreeItemPersonaLayout{border-radius:var(--borderRadiusMedium);outline-color:var(--colorStrokeFocus2);outline-radius:var(--borderRadiusMedium);outline-width:2px;outline-style:solid;}",
+    ".r2f6k57{position:relative;cursor:pointer;display:flex;flex-direction:column;box-sizing:border-box;background-color:var(--colorSubtleBackground);color:var(--colorNeutralForeground2);padding-left:var(--spacingHorizontalNone);}",
+    ".r2f6k57:focus{outline-style:none;}",
+    ".r2f6k57:focus-visible{outline-style:none;}",
+    ".r2f6k57[data-fui-focus-visible]>.fui-TreeItemLayout,.r2f6k57[data-fui-focus-visible]>.fui-TreeItemPersonaLayout{border-radius:var(--borderRadiusMedium);outline-color:var(--colorStrokeFocus2);outline-radius:var(--borderRadiusMedium);outline-width:2px;outline-style:solid;}"
+]);
+const useStyles = /*#__PURE__*/ (0, _react.__styles)({
+    level1: {
+        iytv0q: "f10bgyvd"
+    },
+    level2: {
+        iytv0q: "f1h0rod3"
+    },
+    level3: {
+        iytv0q: "fgoqafk"
+    },
+    level4: {
+        iytv0q: "f75dvuh"
+    },
+    level5: {
+        iytv0q: "fqk7yw6"
+    },
+    level6: {
+        iytv0q: "f1r3z17b"
+    },
+    level7: {
+        iytv0q: "f1hrpd1h"
+    },
+    level8: {
+        iytv0q: "f1iy65d0"
+    },
+    level9: {
+        iytv0q: "ftg42e5"
+    },
+    level10: {
+        iytv0q: "fyat3t"
+    }
+}, {
+    d: [
+        ".f10bgyvd{--fluent-TreeItem--level:1;}",
+        ".f1h0rod3{--fluent-TreeItem--level:2;}",
+        ".fgoqafk{--fluent-TreeItem--level:3;}",
+        ".f75dvuh{--fluent-TreeItem--level:4;}",
+        ".fqk7yw6{--fluent-TreeItem--level:5;}",
+        ".f1r3z17b{--fluent-TreeItem--level:6;}",
+        ".f1hrpd1h{--fluent-TreeItem--level:7;}",
+        ".f1iy65d0{--fluent-TreeItem--level:8;}",
+        ".ftg42e5{--fluent-TreeItem--level:9;}",
+        ".fyat3t{--fluent-TreeItem--level:10;}"
+    ]
+});
+const useTreeItemStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    const styles = useStyles();
+    const { level } = state;
+    state.root.className = (0, _react.mergeClasses)(treeItemClassNames.root, baseStyles, isStaticallyDefinedLevel(level) && styles[`level${level}`], state.root.className);
+    return state;
+};
+function isStaticallyDefinedLevel(level) {
+    return level >= 1 && level <= 10;
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItemStyles.styles.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["useTreeItemStyles.styles.js"],"sourcesContent":["'use client';\nimport { makeResetStyles, makeStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nimport { createCustomFocusIndicatorStyle } from '@fluentui/react-tabster';\nimport { treeItemLevelToken } from '../../utils/tokens';\nimport { treeItemLayoutClassNames } from '../TreeItemLayout/useTreeItemLayoutStyles.styles';\nimport { treeItemPersonaLayoutClassNames } from '../TreeItemPersonaLayout/useTreeItemPersonaLayoutStyles.styles';\nexport const treeItemClassNames = {\n    root: 'fui-TreeItem'\n};\nconst useBaseStyles = makeResetStyles({\n    position: 'relative',\n    cursor: 'pointer',\n    display: 'flex',\n    flexDirection: 'column',\n    boxSizing: 'border-box',\n    backgroundColor: tokens.colorSubtleBackground,\n    color: tokens.colorNeutralForeground2,\n    paddingRight: tokens.spacingHorizontalNone,\n    // if using createCustomFocusIndicatorStyle then we need to remove default outline styles provided by the browser\n    ':focus': {\n        outlineStyle: 'none'\n    },\n    ':focus-visible': {\n        outlineStyle: 'none'\n    },\n    // This adds the focus outline for the TreeItemLayout element\n    ...createCustomFocusIndicatorStyle({\n        borderRadius: tokens.borderRadiusMedium,\n        outlineColor: tokens.colorStrokeFocus2,\n        outlineRadius: tokens.borderRadiusMedium,\n        // FIXME: tokens.strokeWidthThick causes some weird bugs\n        outlineWidth: '2px',\n        outlineStyle: 'solid'\n    }, {\n        customizeSelector: (selector)=>`${selector} > .${treeItemLayoutClassNames.root}, ${selector} > .${treeItemPersonaLayoutClassNames.root}`\n    })\n});\nconst useStyles = makeStyles({\n    ...Object.fromEntries(Array.from({\n        length: 10\n    }, (_, index)=>[\n            `level${index + 1}`,\n            {\n                [treeItemLevelToken]: index + 1\n            }\n        ]))\n});\n/**\n * Apply styling to the TreeItem slots based on the state\n */ export const useTreeItemStyles_unstable = (state)=>{\n    'use no memo';\n    const baseStyles = useBaseStyles();\n    const styles = useStyles();\n    const { level } = state;\n    state.root.className = mergeClasses(treeItemClassNames.root, baseStyles, isStaticallyDefinedLevel(level) && styles[`level${level}`], state.root.className);\n    return state;\n};\nfunction isStaticallyDefinedLevel(level) {\n    return level >= 1 && level <= 10;\n}\n"],"names":["__resetStyles","__styles","mergeClasses","tokens","createCustomFocusIndicatorStyle","treeItemLevelToken","treeItemLayoutClassNames","treeItemPersonaLayoutClassNames","treeItemClassNames","root","useBaseStyles","useStyles","level1","iytv0q","level2","level3","level4","level5","level6","level7","level8","level9","level10","d","useTreeItemStyles_unstable","state","baseStyles","styles","level","className","isStaticallyDefinedLevel"],"mappings":"AAAA,YAAY;;;;;;;;;;;;IAOCQ,kBAAkB;;;8BA2CY;;;;uBAjDe,gBAAgB;AAMnE,2BAA2B;IAC9BC,IAAI,EAAE;AACV,CAAC;AACD,MAAMC,aAAa,GAAA,WAAA,OAAGV,oBAAA,EAAA,YAAA,WAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;IAAA;CA2BrB,CAAC;AACF,MAAMW,SAAS,GAAA,WAAA,OAAGV,eAAA,EAAA;IAAAW,MAAA,EAAA;QAAAC,MAAA,EAAA;IAAA;IAAAC,MAAA,EAAA;QAAAD,MAAA,EAAA;IAAA;IAAAE,MAAA,EAAA;QAAAF,MAAA,EAAA;IAAA;IAAAG,MAAA,EAAA;QAAAH,MAAA,EAAA;IAAA;IAAAI,MAAA,EAAA;QAAAJ,MAAA,EAAA;IAAA;IAAAK,MAAA,EAAA;QAAAL,MAAA,EAAA;IAAA;IAAAM,MAAA,EAAA;QAAAN,MAAA,EAAA;IAAA;IAAAO,MAAA,EAAA;QAAAP,MAAA,EAAA;IAAA;IAAAQ,MAAA,EAAA;QAAAR,MAAA,EAAA;IAAA;IAAAS,OAAA,EAAA;QAAAT,MAAA,EAAA;IAAA;AAAA,GAAA;IAAAU,CAAA,EAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;QAAA;KAAA;AAAA,CASjB,CAAC;AAGS,MAAMC,8BAA8BC,KAAK,IAAG;IACnD,aAAa;IACb,MAAMC,UAAU,GAAGhB,aAAa,CAAC,CAAC;IAClC,MAAMiB,MAAM,GAAGhB,SAAS,CAAC,CAAC;IAC1B,MAAM,EAAEiB,KAAAA,EAAO,GAAGH,KAAK;IACvBA,KAAK,CAAChB,IAAI,CAACoB,SAAS,OAAG3B,mBAAY,EAACM,kBAAkB,CAACC,IAAI,EAAEiB,UAAU,EAAEI,wBAAwB,CAACF,KAAK,CAAC,IAAID,MAAM,CAAC,CAAA,KAAA,EAAQC,KAAK,EAAE,CAAC,EAAEH,KAAK,CAAChB,IAAI,CAACoB,SAAS,CAAC;IAC1J,OAAOJ,KAAK;AAChB,CAAC;AACD,SAASK,wBAAwBA,CAACF,KAAK,EAAE;IACrC,OAAOA,KAAK,IAAI,CAAC,IAAIA,KAAK,IAAI,EAAE;AACpC"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItem/useTreeItemStyles.styles.raw.js

@@ -0,0 +1,77 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemClassNames: function() {
+        return treeItemClassNames;
+    },
+    useTreeItemStyles_unstable: function() {
+        return useTreeItemStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reacttheme = require("@fluentui/react-theme");
+const _reacttabster = require("@fluentui/react-tabster");
+const _tokens = require("../../utils/tokens");
+const _useTreeItemLayoutStylesstyles = require("../TreeItemLayout/useTreeItemLayoutStyles.styles");
+const _useTreeItemPersonaLayoutStylesstyles = require("../TreeItemPersonaLayout/useTreeItemPersonaLayoutStyles.styles");
+const treeItemClassNames = {
+    root: 'fui-TreeItem'
+};
+const useBaseStyles = (0, _react.makeResetStyles)({
+    position: 'relative',
+    cursor: 'pointer',
+    display: 'flex',
+    flexDirection: 'column',
+    boxSizing: 'border-box',
+    backgroundColor: _reacttheme.tokens.colorSubtleBackground,
+    color: _reacttheme.tokens.colorNeutralForeground2,
+    paddingRight: _reacttheme.tokens.spacingHorizontalNone,
+    // if using createCustomFocusIndicatorStyle then we need to remove default outline styles provided by the browser
+    ':focus': {
+        outlineStyle: 'none'
+    },
+    ':focus-visible': {
+        outlineStyle: 'none'
+    },
+    // This adds the focus outline for the TreeItemLayout element
+    ...(0, _reacttabster.createCustomFocusIndicatorStyle)({
+        borderRadius: _reacttheme.tokens.borderRadiusMedium,
+        outlineColor: _reacttheme.tokens.colorStrokeFocus2,
+        outlineRadius: _reacttheme.tokens.borderRadiusMedium,
+        // FIXME: tokens.strokeWidthThick causes some weird bugs
+        outlineWidth: '2px',
+        outlineStyle: 'solid'
+    }, {
+        customizeSelector: (selector)=>`${selector} > .${_useTreeItemLayoutStylesstyles.treeItemLayoutClassNames.root}, ${selector} > .${_useTreeItemPersonaLayoutStylesstyles.treeItemPersonaLayoutClassNames.root}`
+    })
+});
+const useStyles = (0, _react.makeStyles)({
+    ...Object.fromEntries(Array.from({
+        length: 10
+    }, (_, index)=>[
+            `level${index + 1}`,
+            {
+                [_tokens.treeItemLevelToken]: index + 1
+            }
+        ]))
+});
+const useTreeItemStyles_unstable = (state)=>{
+    'use no memo';
+    const baseStyles = useBaseStyles();
+    const styles = useStyles();
+    const { level } = state;
+    state.root.className = (0, _react.mergeClasses)(treeItemClassNames.root, baseStyles, isStaticallyDefinedLevel(level) && styles[`level${level}`], state.root.className);
+    return state;
+};
+function isStaticallyDefinedLevel(level) {
+    return level >= 1 && level <= 10;
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemChevron.js

@@ -0,0 +1,40 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TreeItemChevron", {
+    enumerable: true,
+    get: function() {
+        return TreeItemChevron;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const _reacticons = require("@fluentui/react-icons");
+const _reactmotion = require("@fluentui/react-motion");
+const _treeItemContext = require("../contexts/treeItemContext");
+const TreeItemChevron = /*#__PURE__*/ _react.memo(()=>{
+    const open = (0, _treeItemContext.useTreeItemContext_unstable)((ctx)=>ctx.open);
+    const { dir } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const expandIconRotation = open ? 90 : dir !== 'rtl' ? 0 : 180;
+    return /*#__PURE__*/ _react.createElement(_reacticons.ChevronRight12Regular, {
+        style: {
+            ...expandIconInlineStyles[expandIconRotation],
+            transition: `transform ${_reactmotion.durations.durationNormal}ms ${_reactmotion.curves.curveEasyEaseMax}`
+        }
+    });
+});
+TreeItemChevron.displayName = 'TreeItemChevron';
+const expandIconInlineStyles = {
+    90: {
+        transform: `rotate(90deg)`
+    },
+    0: {
+        transform: `rotate(0deg)`
+    },
+    180: {
+        transform: `rotate(180deg)`
+    }
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemChevron.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemChevron.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useFluent_unstable } from '@fluentui/react-shared-contexts';\nimport { ChevronRight12Regular } from '@fluentui/react-icons';\nimport { durations, curves } from '@fluentui/react-motion';\nimport { useTreeItemContext_unstable } from '../contexts/treeItemContext';\n\nexport const TreeItemChevron = React.memo(() => {\n  const open = useTreeItemContext_unstable(ctx => ctx.open);\n\n  const { dir } = useFluent_unstable();\n\n  const expandIconRotation = open ? 90 : dir !== 'rtl' ? 0 : 180;\n  return (\n    <ChevronRight12Regular\n      style={{\n        ...expandIconInlineStyles[expandIconRotation],\n        transition: `transform ${durations.durationNormal}ms ${curves.curveEasyEaseMax}`,\n      }}\n    />\n  );\n});\nTreeItemChevron.displayName = 'TreeItemChevron';\n\nconst expandIconInlineStyles = {\n  90: { transform: `rotate(90deg)` },\n  0: { transform: `rotate(0deg)` },\n  180: { transform: `rotate(180deg)` },\n} as const;\n"],"names":["React","useFluent_unstable","ChevronRight12Regular","durations","curves","useTreeItemContext_unstable","TreeItemChevron","memo","open","ctx","dir","expandIconRotation","style","expandIconInlineStyles","transition","durationNormal","curveEasyEaseMax","displayName","transform"],"mappings":"AAAA;;;;;+BAQaM;;;;;;;iEANU,QAAQ;qCACI,kCAAkC;4BAC/B,wBAAwB;6BAC5B,yBAAyB;iCACf,8BAA8B;AAEnE,wBAAMA,WAAAA,GAAkBN,OAAMO,IAAI,CAAC;IACxC,MAAMC,WAAOH,4CAAAA,EAA4BI,CAAAA,MAAOA,IAAID,IAAI;IAExD,MAAM,EAAEE,GAAG,EAAE,OAAGT,uCAAAA;IAEhB,MAAMU,qBAAqBH,OAAO,KAAKE,QAAQ,QAAQ,IAAI;IAC3D,OAAA,WAAA,GACE,OAAA,aAAA,CAACR,iCAAAA,EAAAA;QACCU,OAAO;YACL,GAAGC,sBAAsB,CAACF,mBAAmB;YAC7CG,YAAY,CAAC,UAAU,EAAEX,sBAAAA,CAAUY,cAAc,CAAC,GAAG,EAAEX,mBAAAA,CAAOY,gBAAgB,EAAE;QAClF;;AAGN,GAAG;AACHV,gBAAgBW,WAAW,GAAG;AAE9B,MAAMJ,yBAAyB;IAC7B,IAAI;QAAEK,WAAW,CAAC,aAAa,CAAC;IAAC;IACjC,GAAG;QAAEA,WAAW,CAAC,YAAY,CAAC;IAAC;IAC/B,KAAK;QAAEA,WAAW,CAAC,cAAc,CAAC;IAAC;AACrC"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/TreeItemLayout.js

@@ -0,0 +1,24 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TreeItemLayout", {
+    enumerable: true,
+    get: function() {
+        return TreeItemLayout;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTreeItemLayout = require("./useTreeItemLayout");
+const _renderTreeItemLayout = require("./renderTreeItemLayout");
+const _useTreeItemLayoutStylesstyles = require("./useTreeItemLayoutStyles.styles");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const TreeItemLayout = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTreeItemLayout.useTreeItemLayout_unstable)(props, ref);
+    (0, _useTreeItemLayoutStylesstyles.useTreeItemLayoutStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTreeItemLayoutStyles_unstable')(state);
+    return (0, _renderTreeItemLayout.renderTreeItemLayout_unstable)(state);
+});
+TreeItemLayout.displayName = 'TreeItemLayout';

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/TreeItemLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemLayout/TreeItemLayout.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTreeItemLayout_unstable } from './useTreeItemLayout';\nimport { renderTreeItemLayout_unstable } from './renderTreeItemLayout';\nimport { useTreeItemLayoutStyles_unstable } from './useTreeItemLayoutStyles.styles';\nimport type { TreeItemLayoutProps } from './TreeItemLayout.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * The `TreeItemLayout` component is used as a child of `TreeItem` to define the content and layout of a tree item.\n * It provides a consistent visual structure for tree items in a `Tree` component.\n * This component should only be used as a direct child of `TreeItem`.\n */\nexport const TreeItemLayout: ForwardRefComponent<TreeItemLayoutProps> = React.forwardRef((props, ref) => {\n  const state = useTreeItemLayout_unstable(props, ref);\n\n  useTreeItemLayoutStyles_unstable(state);\n  useCustomStyleHook_unstable('useTreeItemLayoutStyles_unstable')(state);\n\n  return renderTreeItemLayout_unstable(state);\n});\n\nTreeItemLayout.displayName = 'TreeItemLayout';\n"],"names":["React","useTreeItemLayout_unstable","renderTreeItemLayout_unstable","useTreeItemLayoutStyles_unstable","useCustomStyleHook_unstable","TreeItemLayout","forwardRef","props","ref","state","displayName"],"mappings":"AAAA;;;;;;;;;;;;iEAEuB,QAAQ;mCACY,sBAAsB;sCACnB,yBAAyB;+CACtB,mCAAmC;qCAGxC,kCAAkC;AAOvE,MAAMK,iBAAAA,WAAAA,GAA2DL,OAAMM,UAAU,CAAC,CAACC,OAAOC;IAC/F,MAAMC,YAAQR,6CAAAA,EAA2BM,OAAOC;QAEhDL,+DAAAA,EAAiCM;QACjCL,gDAAAA,EAA4B,oCAAoCK;IAEhE,WAAOP,mDAAAA,EAA8BO;AACvC,GAAG;AAEHJ,eAAeK,WAAW,GAAG"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/TreeItemLayout.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering TreeItemLayout
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/TreeItemLayout.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemLayout/TreeItemLayout.types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type {\n  Slot,\n  ComponentProps,\n  ComponentState,\n  ExtractSlotProps,\n  EventData,\n  EventHandler,\n} from '@fluentui/react-utilities';\nimport { ButtonContextValue } from '@fluentui/react-button';\nimport { Checkbox } from '@fluentui/react-checkbox';\nimport { Radio } from '@fluentui/react-radio';\n\nexport type TreeItemLayoutActionVisibilityChangeData = (\n  | EventData<'mouseover' | 'mouseout', MouseEvent>\n  | EventData<'focus' | 'blur', FocusEvent>\n  | EventData<'blur', React.FocusEvent>\n) & { visible: boolean };\n\nexport type TreeItemLayoutActionSlotProps = ExtractSlotProps<\n  Slot<'div'> & {\n    /**\n     * Forces visibility of the aside/action content\n     */\n    visible?: boolean;\n    onVisibilityChange?: EventHandler<TreeItemLayoutActionVisibilityChangeData>;\n  }\n>;\n\nexport type TreeItemLayoutSlots = {\n  root: Slot<'div'>;\n  /**\n   * Content. Children of the root slot are automatically rendered here\n   */\n  main: NonNullable<Slot<'div'>>;\n  /**\n   * Icon slot that renders right before main content\n   */\n  iconBefore?: Slot<'div'>;\n  /**\n   * Icon slot that renders right after main content\n   */\n  iconAfter?: Slot<'div'>;\n  /**\n   * Expand icon slot,\n   * by default renders a chevron icon to indicate opening and closing\n   */\n  expandIcon?: Slot<'div'>;\n  /**\n   * Aside content is normally used to render a badge or other non-actionable content\n   */\n  aside?: Slot<'div'>;\n  /**\n   * Actionable elements are normally buttons, menus, or other focusable elements.\n   * Those elements are only visibly available if the given tree item is currently active.\n   *\n   * `actions` and `aside` slots are positioned on the exact same spot,\n   * so they won't be visible at the same time.\n   * `aside` slot is visible by default meanwhile `actions` slot are only visible when the tree item is active.\n   *\n   * `actions` slot supports a `visible` prop to force visibility of the actions.\n   */\n  actions?: Slot<TreeItemLayoutActionSlotProps>;\n  selector?: Slot<typeof Checkbox> | Slot<typeof Radio>;\n};\n\n/**\n * TreeItemLayout Props\n */\nexport type TreeItemLayoutProps = ComponentProps<Partial<TreeItemLayoutSlots>>;\n\n/**\n * State used in rendering TreeItemLayout\n */\nexport type TreeItemLayoutState = ComponentState<TreeItemLayoutSlots> & {\n  buttonContextValue: ButtonContextValue;\n};\n"],"names":[],"mappings":"AAuEA;;CAEC,GACD,WAEE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TreeItemLayout: function() {
+        return _TreeItemLayout.TreeItemLayout;
+    },
+    renderTreeItemLayout_unstable: function() {
+        return _renderTreeItemLayout.renderTreeItemLayout_unstable;
+    },
+    treeItemLayoutClassNames: function() {
+        return _useTreeItemLayoutStylesstyles.treeItemLayoutClassNames;
+    },
+    useTreeItemLayoutStyles_unstable: function() {
+        return _useTreeItemLayoutStylesstyles.useTreeItemLayoutStyles_unstable;
+    },
+    useTreeItemLayout_unstable: function() {
+        return _useTreeItemLayout.useTreeItemLayout_unstable;
+    }
+});
+const _TreeItemLayout = require("./TreeItemLayout");
+const _renderTreeItemLayout = require("./renderTreeItemLayout");
+const _useTreeItemLayout = require("./useTreeItemLayout");
+const _useTreeItemLayoutStylesstyles = require("./useTreeItemLayoutStyles.styles");

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemLayout/index.ts"],"sourcesContent":["export { TreeItemLayout } from './TreeItemLayout';\nexport type {\n  TreeItemLayoutActionSlotProps,\n  TreeItemLayoutActionVisibilityChangeData,\n  TreeItemLayoutProps,\n  TreeItemLayoutSlots,\n  TreeItemLayoutState,\n} from './TreeItemLayout.types';\nexport { renderTreeItemLayout_unstable } from './renderTreeItemLayout';\nexport { useTreeItemLayout_unstable } from './useTreeItemLayout';\nexport { treeItemLayoutClassNames, useTreeItemLayoutStyles_unstable } from './useTreeItemLayoutStyles.styles';\n"],"names":["TreeItemLayout","renderTreeItemLayout_unstable","useTreeItemLayout_unstable","treeItemLayoutClassNames","useTreeItemLayoutStyles_unstable"],"mappings":";;;;;;;;;;;;eAASA,8BAAc;;;eAQdC,mDAA6B;;;eAE7BE,uDAAwB;;;eAAEC,+DAAgC;;;eAD1DF,6CAA0B;;;gCATJ,mBAAmB;sCAQJ,yBAAyB;mCAC5B,sBAAsB;+CACU,mCAAmC"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/renderTreeItemLayout.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTreeItemLayout_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTreeItemLayout_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactbutton = require("@fluentui/react-button");
+const renderTreeItemLayout_unstable = (state)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.expandIcon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.expandIcon, {}),
+            state.selector && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.selector, {}),
+            state.iconBefore && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.iconBefore, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(state.main, {
+                children: state.root.children
+            }),
+            state.iconAfter && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.iconAfter, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_reactbutton.ButtonContextProvider, {
+                value: state.buttonContextValue,
+                children: [
+                    state.actions && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.actions, {}),
+                    state.aside && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.aside, {})
+                ]
+            })
+        ]
+    });
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/renderTreeItemLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemLayout/renderTreeItemLayout.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { JSXElement } from '@fluentui/react-utilities';\nimport type { TreeItemLayoutState, TreeItemLayoutSlots } from './TreeItemLayout.types';\nimport { ButtonContextProvider } from '@fluentui/react-button';\n\n/**\n * Render the final JSX of TreeItemLayout\n */\nexport const renderTreeItemLayout_unstable = (state: TreeItemLayoutState): JSXElement => {\n  assertSlots<TreeItemLayoutSlots>(state);\n\n  return (\n    <state.root>\n      {state.expandIcon && <state.expandIcon />}\n      {state.selector && <state.selector />}\n      {state.iconBefore && <state.iconBefore />}\n      <state.main>{state.root.children}</state.main>\n      {state.iconAfter && <state.iconAfter />}\n      <ButtonContextProvider value={state.buttonContextValue}>\n        {state.actions && <state.actions />}\n        {state.aside && <state.aside />}\n      </ButtonContextProvider>\n    </state.root>\n  );\n};\n"],"names":["assertSlots","ButtonContextProvider","renderTreeItemLayout_unstable","state","root","expandIcon","selector","iconBefore","main","children","iconAfter","value","buttonContextValue","actions","aside"],"mappings":";;;;+BAUaE;;;;;;4BATb,iCAAiD;gCACrB,4BAA4B;6BAGlB,yBAAyB;AAKxD,sCAAsC,CAACC;QAC5CH,2BAAAA,EAAiCG;IAEjC,OAAA,WAAA,OACE,gBAAA,EAACA,MAAMC,IAAI,EAAA;;YACRD,MAAME,UAAU,IAAA,WAAA,OAAI,eAAA,EAACF,MAAME,UAAU,EAAA,CAAA;YACrCF,MAAMG,QAAQ,IAAA,WAAA,GAAI,mBAAA,EAACH,MAAMG,QAAQ,EAAA,CAAA;YACjCH,MAAMI,UAAU,IAAA,WAAA,OAAI,eAAA,EAACJ,MAAMI,UAAU,EAAA,CAAA;8BACtC,eAAA,EAACJ,MAAMK,IAAI,EAAA;0BAAEL,MAAMC,IAAI,CAACK,QAAQ;;YAC/BN,MAAMO,SAAS,IAAA,WAAA,OAAI,eAAA,EAACP,MAAMO,SAAS,EAAA,CAAA;8BACpC,gBAAA,EAACT,kCAAAA,EAAAA;gBAAsBU,OAAOR,MAAMS,kBAAkB;;oBACnDT,MAAMU,OAAO,IAAA,WAAA,OAAI,eAAA,EAACV,MAAMU,OAAO,EAAA,CAAA;oBAC/BV,MAAMW,KAAK,IAAA,WAAA,OAAI,eAAA,EAACX,MAAMW,KAAK,EAAA,CAAA;;;;;AAIpC,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/useTreeItemLayout.js

@@ -0,0 +1,244 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeItemLayout_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeItemLayout_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _contexts = require("../../contexts");
+const _reactcheckbox = require("@fluentui/react-checkbox");
+const _reactradio = require("@fluentui/react-radio");
+const _TreeItemChevron = require("../TreeItemChevron");
+const _reacttabster = require("@fluentui/react-tabster");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const useTreeItemLayout_unstable = (props, ref)=>{
+    'use no memo';
+    const { main, iconAfter, iconBefore } = props;
+    const layoutRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.layoutRef);
+    const selectionMode = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.selectionMode);
+    const navigationMode = (0, _contexts.useTreeContext_unstable)((ctx)=>{
+        var _ctx_navigationMode;
+        return (_ctx_navigationMode = ctx.navigationMode) !== null && _ctx_navigationMode !== void 0 ? _ctx_navigationMode : 'tree';
+    });
+    const [isActionsVisibleFromProps, onActionVisibilityChange] = (0, _reactutilities.isResolvedShorthand)(props.actions) ? [
+        props.actions.visible,
+        props.actions.onVisibilityChange
+    ] : [
+        undefined,
+        undefined
+    ];
+    const [isActionsVisible, setIsActionsVisible] = (0, _reactutilities.useControllableState)({
+        state: isActionsVisibleFromProps,
+        initialState: false
+    });
+    const selectionRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.selectionRef);
+    const expandIconRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.expandIconRef);
+    const actionsRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.actionsRef);
+    const actionsRefInternal = _react.useRef(null);
+    const treeItemRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.treeItemRef);
+    const subtreeRef = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.subtreeRef);
+    const checked = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.checked);
+    const isBranch = (0, _contexts.useTreeItemContext_unstable)((ctx)=>ctx.itemType === 'branch');
+    // FIXME: Asserting is required here, as converting this to RefObject on context type would be a breaking change
+    assertIsRefObject(treeItemRef);
+    // FIXME: Asserting is required here, as converting this to RefObject on context type would be a breaking change
+    assertIsRefObject(subtreeRef);
+    const setActionsVisibleIfNotFromSubtree = _react.useCallback((event)=>{
+        const isTargetFromSubtree = Boolean(subtreeRef.current && (0, _reactutilities.elementContains)(subtreeRef.current, event.target));
+        if (!isTargetFromSubtree) {
+            onActionVisibilityChange === null || onActionVisibilityChange === void 0 ? void 0 : onActionVisibilityChange(event, {
+                visible: true,
+                event,
+                type: event.type
+            });
+            if (event.defaultPrevented) {
+                return;
+            }
+            setIsActionsVisible(true);
+        }
+    }, [
+        subtreeRef,
+        setIsActionsVisible,
+        onActionVisibilityChange
+    ]);
+    const { targetDocument } = (0, _reactsharedcontexts.useFluent_unstable)();
+    const isNavigatingWithKeyboard = (0, _reacttabster.useIsNavigatingWithKeyboard)();
+    const setActionsInvisibleIfNotFromSubtree = _react.useCallback((event)=>{
+        const isRelatedTargetFromActions = ()=>Boolean(actionsRefInternal.current && (0, _reactutilities.elementContains)(actionsRefInternal.current, event.relatedTarget));
+        const isRelatedTargetFromTreeItem = ()=>Boolean(treeItemRef.current && (0, _reactutilities.elementContains)(treeItemRef.current, event.relatedTarget));
+        const isTargetFromActions = ()=>{
+            var _actionsRefInternal_current;
+            return Boolean((_actionsRefInternal_current = actionsRefInternal.current) === null || _actionsRefInternal_current === void 0 ? void 0 : _actionsRefInternal_current.contains(event.target));
+        };
+        if (isRelatedTargetFromActions()) {
+            onActionVisibilityChange === null || onActionVisibilityChange === void 0 ? void 0 : onActionVisibilityChange(event, {
+                visible: true,
+                event,
+                type: event.type
+            });
+            if (event.defaultPrevented) {
+                return;
+            }
+            setIsActionsVisible(true);
+            return;
+        }
+        if (isTargetFromActions() && isRelatedTargetFromTreeItem()) {
+            return;
+        }
+        // when a mouseout event happens during keyboard interaction
+        // we should not hide the actions if the activeElement is the treeitem or an action
+        // as the focus on the treeitem takes precedence over the mouseout event
+        if (event.type === 'mouseout' && isNavigatingWithKeyboard() && ((targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.activeElement) === treeItemRef.current || (0, _reactutilities.elementContains)(actionsRefInternal.current, targetDocument === null || targetDocument === void 0 ? void 0 : targetDocument.activeElement))) {
+            return;
+        }
+        onActionVisibilityChange === null || onActionVisibilityChange === void 0 ? void 0 : onActionVisibilityChange(event, {
+            visible: false,
+            event,
+            type: event.type
+        });
+        if (event.defaultPrevented) {
+            return;
+        }
+        setIsActionsVisible(false);
+    }, [
+        setIsActionsVisible,
+        onActionVisibilityChange,
+        treeItemRef,
+        isNavigatingWithKeyboard,
+        targetDocument
+    ]);
+    const expandIcon = _reactutilities.slot.optional(props.expandIcon, {
+        renderByDefault: isBranch,
+        defaultProps: {
+            children: /*#__PURE__*/ _react.createElement(_TreeItemChevron.TreeItemChevron, null),
+            'aria-hidden': true
+        },
+        elementType: 'div'
+    });
+    const expandIconRefs = (0, _reactutilities.useMergedRefs)(expandIcon === null || expandIcon === void 0 ? void 0 : expandIcon.ref, expandIconRef);
+    if (expandIcon) {
+        expandIcon.ref = expandIconRefs;
+    }
+    const arrowNavigationProps = (0, _reacttabster.useArrowNavigationGroup)({
+        circular: navigationMode === 'tree',
+        axis: 'horizontal'
+    });
+    const actions = isActionsVisible ? _reactutilities.slot.optional(props.actions, {
+        defaultProps: {
+            ...arrowNavigationProps,
+            role: 'toolbar'
+        },
+        elementType: 'div'
+    }) : undefined;
+    actions === null || actions === void 0 ? true : delete actions.visible;
+    actions === null || actions === void 0 ? true : delete actions.onVisibilityChange;
+    const actionsRefs = (0, _reactutilities.useMergedRefs)(actions === null || actions === void 0 ? void 0 : actions.ref, actionsRef, actionsRefInternal);
+    const handleActionsBlur = (0, _reactutilities.useEventCallback)((event)=>{
+        if ((0, _reactutilities.isResolvedShorthand)(props.actions)) {
+            var _props_actions_onBlur, _props_actions;
+            (_props_actions_onBlur = (_props_actions = props.actions).onBlur) === null || _props_actions_onBlur === void 0 ? void 0 : _props_actions_onBlur.call(_props_actions, event);
+        }
+        const isRelatedTargetFromActions = Boolean((0, _reactutilities.elementContains)(event.currentTarget, event.relatedTarget));
+        onActionVisibilityChange === null || onActionVisibilityChange === void 0 ? void 0 : onActionVisibilityChange(event, {
+            visible: isRelatedTargetFromActions,
+            event,
+            type: event.type
+        });
+        setIsActionsVisible(isRelatedTargetFromActions);
+    });
+    if (actions) {
+        actions.ref = actionsRefs;
+        actions.onBlur = handleActionsBlur;
+    }
+    const hasActions = Boolean(props.actions);
+    _react.useEffect(()=>{
+        if (treeItemRef.current && hasActions) {
+            const treeItemElement = treeItemRef.current;
+            const handleMouseOver = setActionsVisibleIfNotFromSubtree;
+            const handleMouseOut = setActionsInvisibleIfNotFromSubtree;
+            const handleFocus = setActionsVisibleIfNotFromSubtree;
+            const handleBlur = setActionsInvisibleIfNotFromSubtree;
+            treeItemElement.addEventListener('mouseover', handleMouseOver);
+            treeItemElement.addEventListener('mouseout', handleMouseOut);
+            treeItemElement.addEventListener('focus', handleFocus);
+            treeItemElement.addEventListener('blur', handleBlur);
+            return ()=>{
+                treeItemElement.removeEventListener('mouseover', handleMouseOver);
+                treeItemElement.removeEventListener('mouseout', handleMouseOut);
+                treeItemElement.removeEventListener('focus', handleFocus);
+                treeItemElement.removeEventListener('blur', handleBlur);
+            };
+        }
+    }, [
+        hasActions,
+        treeItemRef,
+        setActionsVisibleIfNotFromSubtree,
+        setActionsInvisibleIfNotFromSubtree
+    ]);
+    return {
+        components: {
+            root: 'div',
+            expandIcon: 'div',
+            iconBefore: 'div',
+            main: 'div',
+            iconAfter: 'div',
+            actions: 'div',
+            aside: 'div',
+            // Casting here to a union between checkbox and radio
+            selector: selectionMode === 'multiselect' ? _reactcheckbox.Checkbox : _reactradio.Radio
+        },
+        buttonContextValue: {
+            size: 'small'
+        },
+        root: _reactutilities.slot.always((0, _reactutilities.getIntrinsicElementProps)('div', {
+            ...props,
+            // FIXME:
+            // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`
+            // but since it would be a breaking change to fix it, we are casting ref to it's proper type
+            ref: (0, _reactutilities.useMergedRefs)(ref, layoutRef)
+        }), {
+            elementType: 'div'
+        }),
+        iconBefore: _reactutilities.slot.optional(iconBefore, {
+            elementType: 'div'
+        }),
+        main: _reactutilities.slot.always(main, {
+            elementType: 'div'
+        }),
+        iconAfter: _reactutilities.slot.optional(iconAfter, {
+            elementType: 'div'
+        }),
+        aside: !isActionsVisible ? _reactutilities.slot.optional(props.aside, {
+            elementType: 'div'
+        }) : undefined,
+        actions,
+        expandIcon,
+        selector: _reactutilities.slot.optional(props.selector, {
+            renderByDefault: selectionMode !== 'none',
+            defaultProps: {
+                checked,
+                tabIndex: -1,
+                'aria-hidden': true,
+                ref: selectionRef
+            },
+            elementType: selectionMode === 'multiselect' ? _reactcheckbox.Checkbox : _reactradio.Radio
+        })
+    };
+};
+function assertIsRefObject(ref) {
+    if (process.env.NODE_ENV !== 'production') {
+        if (typeof ref !== 'object' || ref === null || !('current' in ref)) {
+            throw new Error(`
+        @fluentui/react-tree [${useTreeItemLayout_unstable.name}]:
+        Internal Error: contextual ref is not a RefObject! Please report this bug immediately, as contextual refs should be RefObjects.
+      `);
+        }
+    }
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/useTreeItemLayoutStyles.styles.js

@@ -0,0 +1,207 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemLayoutClassNames: function() {
+        return treeItemLayoutClassNames;
+    },
+    useTreeItemLayoutStyles_unstable: function() {
+        return useTreeItemLayoutStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _treeContext = require("../../contexts/treeContext");
+const _treeItemContext = require("../../contexts/treeItemContext");
+const treeItemLayoutClassNames = {
+    root: 'fui-TreeItemLayout',
+    iconBefore: 'fui-TreeItemLayout__iconBefore',
+    main: 'fui-TreeItemLayout__main',
+    iconAfter: 'fui-TreeItemLayout__iconAfter',
+    expandIcon: 'fui-TreeItemLayout__expandIcon',
+    aside: 'fui-TreeItemLayout__aside',
+    actions: 'fui-TreeItemLayout__actions',
+    selector: 'fui-TreeItemLayout__selector'
+};
+const useRootBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("ryb8khq", null, [
+    ".ryb8khq{display:flex;align-items:center;min-height:32px;box-sizing:border-box;grid-area:layout;}",
+    ".ryb8khq:hover{color:var(--colorNeutralForeground2Hover);background-color:var(--colorSubtleBackgroundHover);}",
+    ".ryb8khq:hover .fui-TreeItemLayout__expandIcon{color:var(--colorNeutralForeground3Hover);}",
+    ".ryb8khq:active{color:var(--colorNeutralForeground2Pressed);background-color:var(--colorSubtleBackgroundPressed);}",
+    ".ryb8khq:active .fui-TreeItemLayout__expandIcon{color:var(--colorNeutralForeground3Pressed);}"
+]);
+/**
+ * Styles for the root slot
+ */ const useRootStyles = /*#__PURE__*/ (0, _react.__styles)({
+    leaf: {
+        uwmqm3: [
+            "f1k1erfc",
+            "faevyjx"
+        ]
+    },
+    branch: {
+        uwmqm3: [
+            "fo100m9",
+            "f6yw3pu"
+        ]
+    },
+    medium: {
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "fkhj508",
+        Bhrd7zp: "figsok6",
+        Bg96gwp: "f1i3iumi"
+    },
+    small: {
+        sshi5w: "f1pha7fy",
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "fy9rknc",
+        Bhrd7zp: "figsok6",
+        Bg96gwp: "fwrc4pm"
+    },
+    subtle: {},
+    "subtle-alpha": {
+        Jwef8y: "f146ro5n",
+        ecr2s2: "fkam630"
+    },
+    transparent: {
+        De3pzq: "f1c21dwh",
+        Jwef8y: "fjxutwb",
+        ecr2s2: "fophhak"
+    }
+}, {
+    d: [
+        ".f1k1erfc{padding-left:calc(var(--fluent-TreeItem--level, 1) * var(--spacingHorizontalXXL));}",
+        ".faevyjx{padding-right:calc(var(--fluent-TreeItem--level, 1) * var(--spacingHorizontalXXL));}",
+        ".fo100m9{padding-left:calc((var(--fluent-TreeItem--level, 1) - 1) * var(--spacingHorizontalXXL));}",
+        ".f6yw3pu{padding-right:calc((var(--fluent-TreeItem--level, 1) - 1) * var(--spacingHorizontalXXL));}",
+        ".fk6fouc{font-family:var(--fontFamilyBase);}",
+        ".fkhj508{font-size:var(--fontSizeBase300);}",
+        ".figsok6{font-weight:var(--fontWeightRegular);}",
+        ".f1i3iumi{line-height:var(--lineHeightBase300);}",
+        ".f1pha7fy{min-height:24px;}",
+        ".fy9rknc{font-size:var(--fontSizeBase200);}",
+        ".fwrc4pm{line-height:var(--lineHeightBase200);}",
+        ".f1c21dwh{background-color:var(--colorTransparentBackground);}"
+    ],
+    h: [
+        ".f146ro5n:hover{background-color:var(--colorSubtleBackgroundLightAlphaHover);}",
+        ".fjxutwb:hover{background-color:var(--colorTransparentBackgroundHover);}"
+    ],
+    a: [
+        ".fkam630:active{background-color:var(--colorSubtleBackgroundLightAlphaPressed);}",
+        ".fophhak:active{background-color:var(--colorTransparentBackgroundPressed);}"
+    ]
+});
+/**
+ * Styles for the action icon slot
+ */ const useActionsBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rzvs2in", "r17h8a29", [
+    ".rzvs2in{display:flex;margin-left:auto;position:relative;z-index:1;grid-area:aside;padding:0 var(--spacingHorizontalS);}",
+    ".r17h8a29{display:flex;margin-right:auto;position:relative;z-index:1;grid-area:aside;padding:0 var(--spacingHorizontalS);}"
+]);
+/**
+ * Styles for the action icon slot
+ */ const useAsideBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1825u21", "rezy0yk", [
+    ".r1825u21{display:flex;margin-left:auto;align-items:center;z-index:0;grid-area:aside;padding:0 var(--spacingHorizontalM);gap:var(--spacingHorizontalXS);}",
+    ".rezy0yk{display:flex;margin-right:auto;align-items:center;z-index:0;grid-area:aside;padding:0 var(--spacingHorizontalM);gap:var(--spacingHorizontalXS);}"
+]);
+/**
+ * Styles for the expand icon slot
+ */ const useExpandIconBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rh4pu5o", null, [
+    ".rh4pu5o{display:flex;align-items:center;justify-content:center;min-width:24px;box-sizing:border-box;color:var(--colorNeutralForeground3);flex:0 0 auto;padding:var(--spacingVerticalXS) 0;}"
+]);
+/**
+ * Styles for the content slot
+ */ const useMainBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rklbe47", null, [
+    ".rklbe47{padding:0 var(--spacingHorizontalXXS);}"
+]);
+/**
+ * Styles for the before/after icon slot
+ */ const useIconBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rphzgg1", null, [
+    ".rphzgg1{display:flex;align-items:center;color:var(--colorNeutralForeground2);line-height:var(--lineHeightBase500);font-size:var(--fontSizeBase500);}"
+]);
+const useIconBeforeStyles = /*#__PURE__*/ (0, _react.__styles)({
+    medium: {
+        z189sj: [
+            "f7x41pl",
+            "fruq291"
+        ]
+    },
+    small: {
+        z189sj: [
+            "ffczdla",
+            "fgiv446"
+        ]
+    }
+}, {
+    d: [
+        ".f7x41pl{padding-right:var(--spacingHorizontalXS);}",
+        ".fruq291{padding-left:var(--spacingHorizontalXS);}",
+        ".ffczdla{padding-right:var(--spacingHorizontalXXS);}",
+        ".fgiv446{padding-left:var(--spacingHorizontalXXS);}"
+    ]
+});
+const useIconAfterStyles = /*#__PURE__*/ (0, _react.__styles)({
+    medium: {
+        uwmqm3: [
+            "fruq291",
+            "f7x41pl"
+        ]
+    },
+    small: {
+        uwmqm3: [
+            "fgiv446",
+            "ffczdla"
+        ]
+    }
+}, {
+    d: [
+        ".fruq291{padding-left:var(--spacingHorizontalXS);}",
+        ".f7x41pl{padding-right:var(--spacingHorizontalXS);}",
+        ".fgiv446{padding-left:var(--spacingHorizontalXXS);}",
+        ".ffczdla{padding-right:var(--spacingHorizontalXXS);}"
+    ]
+});
+const useTreeItemLayoutStyles_unstable = (state)=>{
+    'use no memo';
+    const { main, iconAfter, iconBefore, expandIcon, root, aside, actions, selector } = state;
+    const rootStyles = useRootStyles();
+    const rootBaseStyles = useRootBaseStyles();
+    const actionsBaseStyles = useActionsBaseStyles();
+    const asideBaseStyles = useAsideBaseStyles();
+    const mainBaseStyles = useMainBaseStyles();
+    const expandIconBaseStyles = useExpandIconBaseStyles();
+    const iconBaseStyles = useIconBaseStyles();
+    const iconBeforeStyles = useIconBeforeStyles();
+    const iconAfterStyles = useIconAfterStyles();
+    const size = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.size);
+    const appearance = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.appearance);
+    const itemType = (0, _treeItemContext.useTreeItemContext_unstable)((ctx)=>ctx.itemType);
+    root.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.root, rootBaseStyles, rootStyles[appearance], rootStyles[size], rootStyles[itemType], root.className);
+    main.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.main, mainBaseStyles, main.className);
+    if (expandIcon) {
+        expandIcon.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.expandIcon, expandIconBaseStyles, expandIcon.className);
+    }
+    if (iconBefore) {
+        iconBefore.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.iconBefore, iconBaseStyles, iconBeforeStyles[size], iconBefore.className);
+    }
+    if (iconAfter) {
+        iconAfter.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.iconAfter, iconBaseStyles, iconAfterStyles[size], iconAfter.className);
+    }
+    if (actions) {
+        actions.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.actions, actionsBaseStyles, actions.className);
+    }
+    if (aside) {
+        aside.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.aside, asideBaseStyles, aside.className);
+    }
+    if (selector) {
+        selector.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.selector, selector.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemLayout/useTreeItemLayoutStyles.styles.raw.js

@@ -0,0 +1,193 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemLayoutClassNames: function() {
+        return treeItemLayoutClassNames;
+    },
+    useTreeItemLayoutStyles_unstable: function() {
+        return useTreeItemLayoutStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reacttheme = require("@fluentui/react-theme");
+const _treeContext = require("../../contexts/treeContext");
+const _tokens = require("../../utils/tokens");
+const _treeItemContext = require("../../contexts/treeItemContext");
+const treeItemLayoutClassNames = {
+    root: 'fui-TreeItemLayout',
+    iconBefore: 'fui-TreeItemLayout__iconBefore',
+    main: 'fui-TreeItemLayout__main',
+    iconAfter: 'fui-TreeItemLayout__iconAfter',
+    expandIcon: 'fui-TreeItemLayout__expandIcon',
+    aside: 'fui-TreeItemLayout__aside',
+    actions: 'fui-TreeItemLayout__actions',
+    selector: 'fui-TreeItemLayout__selector'
+};
+const useRootBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    alignItems: 'center',
+    minHeight: '32px',
+    boxSizing: 'border-box',
+    gridArea: 'layout',
+    ':hover': {
+        color: _reacttheme.tokens.colorNeutralForeground2Hover,
+        backgroundColor: _reacttheme.tokens.colorSubtleBackgroundHover,
+        // TODO: stop using treeItemLayoutClassNames.expandIcon  for styling
+        [`& .${treeItemLayoutClassNames.expandIcon}`]: {
+            color: _reacttheme.tokens.colorNeutralForeground3Hover
+        }
+    },
+    ':active': {
+        color: _reacttheme.tokens.colorNeutralForeground2Pressed,
+        backgroundColor: _reacttheme.tokens.colorSubtleBackgroundPressed,
+        // TODO: stop using treeItemLayoutClassNames.expandIcon for styling
+        [`& .${treeItemLayoutClassNames.expandIcon}`]: {
+            color: _reacttheme.tokens.colorNeutralForeground3Pressed
+        }
+    }
+});
+/**
+ * Styles for the root slot
+ */ const useRootStyles = (0, _react.makeStyles)({
+    leaf: {
+        paddingLeft: `calc(var(${_tokens.treeItemLevelToken}, 1) * ${_reacttheme.tokens.spacingHorizontalXXL})`
+    },
+    branch: {
+        paddingLeft: `calc((var(${_tokens.treeItemLevelToken}, 1) - 1) * ${_reacttheme.tokens.spacingHorizontalXXL})`
+    },
+    medium: {
+        ..._reacttheme.typographyStyles.body1
+    },
+    small: {
+        minHeight: '24px',
+        ..._reacttheme.typographyStyles.caption1
+    },
+    // Appearance variations
+    subtle: {},
+    'subtle-alpha': {
+        ':hover': {
+            backgroundColor: _reacttheme.tokens.colorSubtleBackgroundLightAlphaHover
+        },
+        ':active': {
+            backgroundColor: _reacttheme.tokens.colorSubtleBackgroundLightAlphaPressed
+        }
+    },
+    transparent: {
+        backgroundColor: _reacttheme.tokens.colorTransparentBackground,
+        ':hover': {
+            backgroundColor: _reacttheme.tokens.colorTransparentBackgroundHover
+        },
+        ':active': {
+            backgroundColor: _reacttheme.tokens.colorTransparentBackgroundPressed
+        }
+    }
+});
+/**
+ * Styles for the action icon slot
+ */ const useActionsBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    marginLeft: 'auto',
+    position: 'relative',
+    zIndex: 1,
+    gridArea: 'aside',
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalS}`
+});
+/**
+ * Styles for the action icon slot
+ */ const useAsideBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    marginLeft: 'auto',
+    alignItems: 'center',
+    zIndex: 0,
+    gridArea: 'aside',
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalM}`,
+    gap: _reacttheme.tokens.spacingHorizontalXS
+});
+/**
+ * Styles for the expand icon slot
+ */ const useExpandIconBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    minWidth: '24px',
+    boxSizing: 'border-box',
+    color: _reacttheme.tokens.colorNeutralForeground3,
+    flex: `0 0 auto`,
+    padding: `${_reacttheme.tokens.spacingVerticalXS} 0`
+});
+/**
+ * Styles for the content slot
+ */ const useMainBaseStyles = (0, _react.makeResetStyles)({
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalXXS}`
+});
+/**
+ * Styles for the before/after icon slot
+ */ const useIconBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    alignItems: 'center',
+    color: _reacttheme.tokens.colorNeutralForeground2,
+    lineHeight: _reacttheme.tokens.lineHeightBase500,
+    fontSize: _reacttheme.tokens.fontSizeBase500
+});
+const useIconBeforeStyles = (0, _react.makeStyles)({
+    medium: {
+        paddingRight: _reacttheme.tokens.spacingHorizontalXS
+    },
+    small: {
+        paddingRight: _reacttheme.tokens.spacingHorizontalXXS
+    }
+});
+const useIconAfterStyles = (0, _react.makeStyles)({
+    medium: {
+        paddingLeft: _reacttheme.tokens.spacingHorizontalXS
+    },
+    small: {
+        paddingLeft: _reacttheme.tokens.spacingHorizontalXXS
+    }
+});
+const useTreeItemLayoutStyles_unstable = (state)=>{
+    'use no memo';
+    const { main, iconAfter, iconBefore, expandIcon, root, aside, actions, selector } = state;
+    const rootStyles = useRootStyles();
+    const rootBaseStyles = useRootBaseStyles();
+    const actionsBaseStyles = useActionsBaseStyles();
+    const asideBaseStyles = useAsideBaseStyles();
+    const mainBaseStyles = useMainBaseStyles();
+    const expandIconBaseStyles = useExpandIconBaseStyles();
+    const iconBaseStyles = useIconBaseStyles();
+    const iconBeforeStyles = useIconBeforeStyles();
+    const iconAfterStyles = useIconAfterStyles();
+    const size = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.size);
+    const appearance = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.appearance);
+    const itemType = (0, _treeItemContext.useTreeItemContext_unstable)((ctx)=>ctx.itemType);
+    root.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.root, rootBaseStyles, rootStyles[appearance], rootStyles[size], rootStyles[itemType], root.className);
+    main.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.main, mainBaseStyles, main.className);
+    if (expandIcon) {
+        expandIcon.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.expandIcon, expandIconBaseStyles, expandIcon.className);
+    }
+    if (iconBefore) {
+        iconBefore.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.iconBefore, iconBaseStyles, iconBeforeStyles[size], iconBefore.className);
+    }
+    if (iconAfter) {
+        iconAfter.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.iconAfter, iconBaseStyles, iconAfterStyles[size], iconAfter.className);
+    }
+    if (actions) {
+        actions.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.actions, actionsBaseStyles, actions.className);
+    }
+    if (aside) {
+        aside.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.aside, asideBaseStyles, aside.className);
+    }
+    if (selector) {
+        selector.className = (0, _react.mergeClasses)(treeItemLayoutClassNames.selector, selector.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/TreeItemPersonaLayout.js

@@ -0,0 +1,26 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "TreeItemPersonaLayout", {
+    enumerable: true,
+    get: function() {
+        return TreeItemPersonaLayout;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _useTreeItemPersonaLayout = require("./useTreeItemPersonaLayout");
+const _renderTreeItemPersonaLayout = require("./renderTreeItemPersonaLayout");
+const _useTreeItemPersonaLayoutStylesstyles = require("./useTreeItemPersonaLayoutStyles.styles");
+const _useTreeItemPersonaLayoutContextValues = require("./useTreeItemPersonaLayoutContextValues");
+const _reactsharedcontexts = require("@fluentui/react-shared-contexts");
+const TreeItemPersonaLayout = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useTreeItemPersonaLayout.useTreeItemPersonaLayout_unstable)(props, ref);
+    (0, _useTreeItemPersonaLayoutStylesstyles.useTreeItemPersonaLayoutStyles_unstable)(state);
+    (0, _reactsharedcontexts.useCustomStyleHook_unstable)('useTreeItemPersonaLayoutStyles_unstable')(state);
+    const contextValues = (0, _useTreeItemPersonaLayoutContextValues.useTreeItemPersonaLayoutContextValues_unstable)(state);
+    return (0, _renderTreeItemPersonaLayout.renderTreeItemPersonaLayout_unstable)(state, contextValues);
+});
+TreeItemPersonaLayout.displayName = 'TreeItemPersonaLayout';

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/TreeItemPersonaLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/TreeItemPersonaLayout.tsx"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport { useTreeItemPersonaLayout_unstable } from './useTreeItemPersonaLayout';\nimport { renderTreeItemPersonaLayout_unstable } from './renderTreeItemPersonaLayout';\nimport { useTreeItemPersonaLayoutStyles_unstable } from './useTreeItemPersonaLayoutStyles.styles';\nimport type { TreeItemPersonaLayoutProps } from './TreeItemPersonaLayout.types';\nimport type { ForwardRefComponent } from '@fluentui/react-utilities';\nimport { useTreeItemPersonaLayoutContextValues_unstable } from './useTreeItemPersonaLayoutContextValues';\nimport { useCustomStyleHook_unstable } from '@fluentui/react-shared-contexts';\n\n/**\n * The `TreeItemPersonaLayout` component is used as a child of `TreeItem` to display a `TreeItem` with a media (typically an avatar) and a description.\n * It provides a more visually appealing representation of a `TreeItem` and is typically used to display a list of people or topics.\n * This component should only be used as a direct child of `TreeItem`.\n */\nexport const TreeItemPersonaLayout: ForwardRefComponent<TreeItemPersonaLayoutProps> = React.forwardRef((props, ref) => {\n  const state = useTreeItemPersonaLayout_unstable(props, ref);\n\n  useTreeItemPersonaLayoutStyles_unstable(state);\n  useCustomStyleHook_unstable('useTreeItemPersonaLayoutStyles_unstable')(state);\n\n  const contextValues = useTreeItemPersonaLayoutContextValues_unstable(state);\n\n  return renderTreeItemPersonaLayout_unstable(state, contextValues);\n});\n\nTreeItemPersonaLayout.displayName = 'TreeItemPersonaLayout';\n"],"names":["React","useTreeItemPersonaLayout_unstable","renderTreeItemPersonaLayout_unstable","useTreeItemPersonaLayoutStyles_unstable","useTreeItemPersonaLayoutContextValues_unstable","useCustomStyleHook_unstable","TreeItemPersonaLayout","forwardRef","props","ref","state","contextValues","displayName"],"mappings":"AAAA;;;;;;;;;;;;iEAEuB,QAAQ;0CACmB,6BAA6B;6CAC1B,gCAAgC;sDAC7B,0CAA0C;uDAGnC,0CAA0C;qCAC7D,kCAAkC;AAOvE,MAAMM,wBAAAA,WAAAA,GAAyEN,OAAMO,UAAU,CAAC,CAACC,OAAOC;IAC7G,MAAMC,YAAQT,2DAAAA,EAAkCO,OAAOC;QAEvDN,6EAAAA,EAAwCO;QACxCL,gDAAAA,EAA4B,2CAA2CK;IAEvE,MAAMC,oBAAgBP,qFAAAA,EAA+CM;IAErE,WAAOR,iEAAAA,EAAqCQ,OAAOC;AACrD,GAAG;AAEHL,sBAAsBM,WAAW,GAAG"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/TreeItemPersonaLayout.types.js

@@ -0,0 +1,6 @@
+/**
+ * State used in rendering TreeItemPersonaLayout
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/TreeItemPersonaLayout.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/TreeItemPersonaLayout.types.ts"],"sourcesContent":["import type { ComponentProps, ComponentState, Slot } from '@fluentui/react-utilities';\nimport type { AvatarContextValue, AvatarSize } from '@fluentui/react-avatar';\nimport { ButtonContextValue } from '@fluentui/react-button';\nimport { TreeItemLayoutSlots } from '../TreeItemLayout/TreeItemLayout.types';\n\nexport type TreeItemPersonaLayoutContextValues = {\n  avatar: AvatarContextValue;\n};\n\nexport type TreeItemPersonaLayoutSlots = Pick<TreeItemLayoutSlots, 'actions' | 'aside' | 'expandIcon' | 'selector'> & {\n  root: NonNullable<Slot<'div'>>;\n  /**\n   * Avatar to display.\n   */\n  media: NonNullable<Slot<'div'>>;\n  /**\n   * Content. Children of the root slot are automatically rendered here\n   */\n  main: NonNullable<Slot<'div'>>;\n  /**\n   * Secondary text that describes or complements the content\n   */\n  description?: Slot<'div'>;\n};\n\n/**\n * TreeItemPersonaLayout Props\n */\nexport type TreeItemPersonaLayoutProps = ComponentProps<Partial<TreeItemPersonaLayoutSlots>>;\n\n/**\n * State used in rendering TreeItemPersonaLayout\n */\nexport type TreeItemPersonaLayoutState = ComponentState<TreeItemPersonaLayoutSlots> & {\n  avatarSize: AvatarSize;\n  buttonContextValue: ButtonContextValue;\n};\n"],"names":[],"mappings":"AA8BA;;CAEC,GACD,WAGE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TreeItemPersonaLayout: function() {
+        return _TreeItemPersonaLayout.TreeItemPersonaLayout;
+    },
+    renderTreeItemPersonaLayout_unstable: function() {
+        return _renderTreeItemPersonaLayout.renderTreeItemPersonaLayout_unstable;
+    },
+    treeItemPersonaLayoutClassNames: function() {
+        return _useTreeItemPersonaLayoutStylesstyles.treeItemPersonaLayoutClassNames;
+    },
+    useTreeItemPersonaLayoutStyles_unstable: function() {
+        return _useTreeItemPersonaLayoutStylesstyles.useTreeItemPersonaLayoutStyles_unstable;
+    },
+    useTreeItemPersonaLayout_unstable: function() {
+        return _useTreeItemPersonaLayout.useTreeItemPersonaLayout_unstable;
+    }
+});
+const _TreeItemPersonaLayout = require("./TreeItemPersonaLayout");
+const _renderTreeItemPersonaLayout = require("./renderTreeItemPersonaLayout");
+const _useTreeItemPersonaLayout = require("./useTreeItemPersonaLayout");
+const _useTreeItemPersonaLayoutStylesstyles = require("./useTreeItemPersonaLayoutStyles.styles");

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/index.ts"],"sourcesContent":["export { TreeItemPersonaLayout } from './TreeItemPersonaLayout';\nexport type {\n  TreeItemPersonaLayoutContextValues,\n  TreeItemPersonaLayoutProps,\n  TreeItemPersonaLayoutSlots,\n  TreeItemPersonaLayoutState,\n} from './TreeItemPersonaLayout.types';\nexport { renderTreeItemPersonaLayout_unstable } from './renderTreeItemPersonaLayout';\nexport { useTreeItemPersonaLayout_unstable } from './useTreeItemPersonaLayout';\nexport {\n  treeItemPersonaLayoutClassNames,\n  useTreeItemPersonaLayoutStyles_unstable,\n} from './useTreeItemPersonaLayoutStyles.styles';\n"],"names":["TreeItemPersonaLayout","renderTreeItemPersonaLayout_unstable","useTreeItemPersonaLayout_unstable","treeItemPersonaLayoutClassNames","useTreeItemPersonaLayoutStyles_unstable"],"mappings":";;;;;;;;;;;;eAASA,4CAAqB;;;eAOrBC,iEAAoC;;;eAG3CE,qEAA+B;;;eAC/BC,6EAAuC;;;eAHhCF,2DAAiC;;;uCARJ,0BAA0B;6CAOX,gCAAgC;0CACnC,6BAA6B;sDAIxE,0CAA0C"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/renderTreeItemPersonaLayout.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "renderTreeItemPersonaLayout_unstable", {
+    enumerable: true,
+    get: function() {
+        return renderTreeItemPersonaLayout_unstable;
+    }
+});
+const _jsxruntime = require("@fluentui/react-jsx-runtime/jsx-runtime");
+const _reactutilities = require("@fluentui/react-utilities");
+const _reactavatar = require("@fluentui/react-avatar");
+const _reactbutton = require("@fluentui/react-button");
+const renderTreeItemPersonaLayout_unstable = (state, contextValues)=>{
+    (0, _reactutilities.assertSlots)(state);
+    return /*#__PURE__*/ (0, _jsxruntime.jsxs)(state.root, {
+        children: [
+            state.expandIcon && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.expandIcon, {}),
+            state.selector && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.selector, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(_reactavatar.AvatarContextProvider, {
+                value: contextValues.avatar,
+                children: /*#__PURE__*/ (0, _jsxruntime.jsx)(state.media, {})
+            }),
+            /*#__PURE__*/ (0, _jsxruntime.jsx)(state.main, {}),
+            state.description && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.description, {}),
+            /*#__PURE__*/ (0, _jsxruntime.jsxs)(_reactbutton.ButtonContextProvider, {
+                value: state.buttonContextValue,
+                children: [
+                    state.actions && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.actions, {}),
+                    state.aside && /*#__PURE__*/ (0, _jsxruntime.jsx)(state.aside, {})
+                ]
+            })
+        ]
+    });
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/renderTreeItemPersonaLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/renderTreeItemPersonaLayout.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } from '@fluentui/react-utilities';\nimport type { JSXElement } from '@fluentui/react-utilities';\nimport type {\n  TreeItemPersonaLayoutState,\n  TreeItemPersonaLayoutContextValues,\n  TreeItemPersonaLayoutSlots,\n} from './TreeItemPersonaLayout.types';\nimport { AvatarContextProvider } from '@fluentui/react-avatar';\nimport { ButtonContextProvider } from '@fluentui/react-button';\n\n/**\n * Render the final JSX of TreeItemPersonaLayout\n */\nexport const renderTreeItemPersonaLayout_unstable = (\n  state: TreeItemPersonaLayoutState,\n  contextValues: TreeItemPersonaLayoutContextValues,\n): JSXElement => {\n  assertSlots<TreeItemPersonaLayoutSlots>(state);\n\n  return (\n    <state.root>\n      {state.expandIcon && <state.expandIcon />}\n      {state.selector && <state.selector />}\n      <AvatarContextProvider value={contextValues.avatar}>\n        <state.media />\n      </AvatarContextProvider>\n      <state.main />\n      {state.description && <state.description />}\n      <ButtonContextProvider value={state.buttonContextValue}>\n        {state.actions && <state.actions />}\n        {state.aside && <state.aside />}\n      </ButtonContextProvider>\n    </state.root>\n  );\n};\n"],"names":["assertSlots","AvatarContextProvider","ButtonContextProvider","renderTreeItemPersonaLayout_unstable","state","contextValues","root","expandIcon","selector","value","avatar","media","main","description","buttonContextValue","actions","aside"],"mappings":";;;;+BAeaG;;;;;;4BAdb,iCAAiD;gCACrB,4BAA4B;6BAOlB,yBAAyB;6BACzB,yBAAyB;AAKxD,6CAA6C,CAClDC,OACAC;QAEAL,2BAAAA,EAAwCI;IAExC,OAAA,WAAA,OACE,gBAAA,EAACA,MAAME,IAAI,EAAA;;YACRF,MAAMG,UAAU,IAAA,WAAA,OAAI,eAAA,EAACH,MAAMG,UAAU,EAAA,CAAA;YACrCH,MAAMI,QAAQ,IAAA,WAAA,OAAI,eAAA,EAACJ,MAAMI,QAAQ,EAAA,CAAA;8BAClC,eAAA,EAACP,kCAAAA,EAAAA;gBAAsBQ,OAAOJ,cAAcK,MAAM;0BAChD,WAAA,OAAA,eAAA,EAACN,MAAMO,KAAK,EAAA,CAAA;;0BAEd,mBAAA,EAACP,MAAMQ,IAAI,EAAA,CAAA;YACVR,MAAMS,WAAW,IAAA,WAAA,OAAI,eAAA,EAACT,MAAMS,WAAW,EAAA,CAAA;8BACxC,gBAAA,EAACX,kCAAAA,EAAAA;gBAAsBO,OAAOL,MAAMU,kBAAkB;;oBACnDV,MAAMW,OAAO,IAAA,WAAA,OAAI,eAAA,EAACX,MAAMW,OAAO,EAAA,CAAA;oBAC/BX,MAAMY,KAAK,IAAA,WAAA,OAAI,eAAA,EAACZ,MAAMY,KAAK,EAAA,CAAA;;;;;AAIpC,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayout.js

@@ -0,0 +1,56 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeItemPersonaLayout_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeItemPersonaLayout_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _reactutilities = require("@fluentui/react-utilities");
+const _contexts = require("../../contexts");
+const _tokens = require("../../utils/tokens");
+const _useTreeItemLayout = require("../TreeItemLayout/useTreeItemLayout");
+const _reactcheckbox = require("@fluentui/react-checkbox");
+const _reactradio = require("@fluentui/react-radio");
+const useTreeItemPersonaLayout_unstable = (props, ref)=>{
+    const { media, children, main, description } = props;
+    const treeItemLayoutState = (0, _useTreeItemLayout.useTreeItemLayout_unstable)({
+        ...props,
+        iconBefore: null,
+        iconAfter: null
+    }, ref);
+    const size = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.size);
+    const selectionMode = (0, _contexts.useTreeContext_unstable)((ctx)=>ctx.selectionMode);
+    return {
+        ...treeItemLayoutState,
+        components: {
+            expandIcon: 'div',
+            main: 'div',
+            description: 'div',
+            root: 'div',
+            media: 'div',
+            aside: 'div',
+            actions: 'div',
+            // Casting here to a union between checkbox and radio
+            selector: selectionMode === 'multiselect' ? _reactcheckbox.Checkbox : _reactradio.Radio
+        },
+        avatarSize: _tokens.treeAvatarSize[size],
+        main: _reactutilities.slot.always(main, {
+            defaultProps: {
+                children
+            },
+            elementType: 'div'
+        }),
+        media: _reactutilities.slot.always(media, {
+            elementType: 'div'
+        }),
+        description: _reactutilities.slot.optional(description, {
+            elementType: 'div'
+        })
+    };
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayout.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/useTreeItemPersonaLayout.ts"],"sourcesContent":["'use client';\n\nimport * as React from 'react';\nimport type { TreeItemPersonaLayoutProps, TreeItemPersonaLayoutState } from './TreeItemPersonaLayout.types';\nimport { slot } from '@fluentui/react-utilities';\nimport { useTreeContext_unstable } from '../../contexts';\nimport { treeAvatarSize } from '../../utils/tokens';\nimport { useTreeItemLayout_unstable } from '../TreeItemLayout/useTreeItemLayout';\nimport { Checkbox, CheckboxProps } from '@fluentui/react-checkbox';\nimport { Radio, RadioProps } from '@fluentui/react-radio';\n\n/**\n * Create the state required to render TreeItemPersonaLayout.\n *\n * The returned state can be modified with hooks such as useTreeItemPersonaLayoutStyles_unstable,\n * before being passed to renderTreeItemPersonaLayout_unstable.\n *\n * @param props - props from this instance of TreeItemPersonaLayout\n * @param ref - reference to root HTMLElement of TreeItemPersonaLayout\n */\nexport const useTreeItemPersonaLayout_unstable = (\n  props: TreeItemPersonaLayoutProps,\n  ref: React.Ref<HTMLSpanElement>,\n): TreeItemPersonaLayoutState => {\n  const { media, children, main, description } = props;\n\n  const treeItemLayoutState = useTreeItemLayout_unstable(\n    {\n      ...props,\n      iconBefore: null,\n      iconAfter: null,\n    },\n    ref,\n  );\n\n  const size = useTreeContext_unstable(ctx => ctx.size);\n  const selectionMode = useTreeContext_unstable(ctx => ctx.selectionMode);\n\n  return {\n    ...treeItemLayoutState,\n    components: {\n      expandIcon: 'div',\n      main: 'div',\n      description: 'div',\n      root: 'div',\n      media: 'div',\n      aside: 'div',\n      actions: 'div',\n      // Casting here to a union between checkbox and radio\n      selector: (selectionMode === 'multiselect' ? Checkbox : Radio) as React.ElementType<CheckboxProps | RadioProps>,\n    },\n    avatarSize: treeAvatarSize[size],\n    main: slot.always(main, { defaultProps: { children }, elementType: 'div' }),\n    media: slot.always(media, { elementType: 'div' }),\n    description: slot.optional(description, { elementType: 'div' }),\n  };\n};\n"],"names":["React","slot","useTreeContext_unstable","treeAvatarSize","useTreeItemLayout_unstable","Checkbox","Radio","useTreeItemPersonaLayout_unstable","props","ref","media","children","main","description","treeItemLayoutState","iconBefore","iconAfter","size","ctx","selectionMode","components","expandIcon","root","aside","actions","selector","avatarSize","always","defaultProps","elementType","optional"],"mappings":"AAAA;;;;;+BAoBaO;;;;;;;iEAlBU,QAAQ;gCAEV,4BAA4B;0BACT,iBAAiB;wBAC1B,qBAAqB;mCACT,sCAAsC;+BACzC,2BAA2B;4BACjC,wBAAwB;AAWnD,0CAA0C,CAC/CC,OACAC;IAEA,MAAM,EAAEC,KAAK,EAAEC,QAAQ,EAAEC,IAAI,EAAEC,WAAW,EAAE,GAAGL;IAE/C,MAAMM,0BAAsBV,6CAAAA,EAC1B;QACE,GAAGI,KAAK;QACRO,YAAY;QACZC,WAAW;IACb,GACAP;IAGF,MAAMQ,WAAOf,iCAAAA,EAAwBgB,CAAAA,MAAOA,IAAID,IAAI;IACpD,MAAME,oBAAgBjB,iCAAAA,EAAwBgB,CAAAA,MAAOA,IAAIC,aAAa;IAEtE,OAAO;QACL,GAAGL,mBAAmB;QACtBM,YAAY;YACVC,YAAY;YACZT,MAAM;YACNC,aAAa;YACbS,MAAM;YACNZ,OAAO;YACPa,OAAO;YACPC,SAAS;YACT,qDAAqD;YACrDC,UAAWN,kBAAkB,gBAAgBd,uBAAAA,GAAWC,iBAAAA;QAC1D;QACAoB,YAAYvB,sBAAc,CAACc,KAAK;QAChCL,MAAMX,oBAAAA,CAAK0B,MAAM,CAACf,MAAM;YAAEgB,cAAc;gBAAEjB;YAAS;YAAGkB,aAAa;QAAM;QACzEnB,OAAOT,oBAAAA,CAAK0B,MAAM,CAACjB,OAAO;YAAEmB,aAAa;QAAM;QAC/ChB,aAAaZ,oBAAAA,CAAK6B,QAAQ,CAACjB,aAAa;YAAEgB,aAAa;QAAM;IAC/D;AACF,EAAE"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayoutContextValues.js

@@ -0,0 +1,24 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useTreeItemPersonaLayoutContextValues_unstable", {
+    enumerable: true,
+    get: function() {
+        return useTreeItemPersonaLayoutContextValues_unstable;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+function useTreeItemPersonaLayoutContextValues_unstable(state) {
+    const { avatarSize } = state;
+    const avatar = _react.useMemo(()=>({
+            size: avatarSize
+        }), [
+        avatarSize
+    ]);
+    return {
+        avatar
+    };
+}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayoutContextValues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeItemPersonaLayout/useTreeItemPersonaLayoutContextValues.ts"],"sourcesContent":["'use client';\n\nimport type { AvatarContextValue } from '@fluentui/react-avatar';\nimport * as React from 'react';\nimport type { TreeItemPersonaLayoutState, TreeItemPersonaLayoutContextValues } from './TreeItemPersonaLayout.types';\n\nexport function useTreeItemPersonaLayoutContextValues_unstable(\n  state: TreeItemPersonaLayoutState,\n): TreeItemPersonaLayoutContextValues {\n  const { avatarSize } = state;\n\n  const avatar = React.useMemo<AvatarContextValue>(() => ({ size: avatarSize }), [avatarSize]);\n\n  return { avatar };\n}\n"],"names":["React","useTreeItemPersonaLayoutContextValues_unstable","state","avatarSize","avatar","useMemo","size"],"mappings":"AAAA;;;;;;;;;;;;iEAGuB,QAAQ;AAGxB,SAASC,+CACdC,KAAiC;IAEjC,MAAM,EAAEC,UAAU,EAAE,GAAGD;IAEvB,MAAME,SAASJ,OAAMK,OAAO,CAAqB,IAAO,CAAA;YAAEC,MAAMH;SAAW,CAAA,EAAI;QAACA;KAAW;IAE3F,OAAO;QAAEC;IAAO;AAClB"}

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayoutStyles.styles.js

@@ -0,0 +1,195 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemPersonaLayoutClassNames: function() {
+        return treeItemPersonaLayoutClassNames;
+    },
+    useTreeItemPersonaLayoutStyles_unstable: function() {
+        return useTreeItemPersonaLayoutStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _treeItemContext = require("../../contexts/treeItemContext");
+const _treeContext = require("../../contexts/treeContext");
+const treeItemPersonaLayoutClassNames = {
+    root: 'fui-TreeItemPersonaLayout',
+    media: 'fui-TreeItemPersonaLayout__media',
+    description: 'fui-TreeItemPersonaLayout__description',
+    main: 'fui-TreeItemPersonaLayout__main',
+    expandIcon: 'fui-TreeItemPersonaLayout__expandIcon',
+    aside: 'fui-TreeItemPersonaLayout__aside',
+    actions: 'fui-TreeItemPersonaLayout__actions',
+    selector: 'fui-TreeItemPersonaLayout__selector'
+};
+const useRootBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1r98egg", null, [
+    ".r1r98egg{display:grid;grid-template-rows:1fr auto;grid-template-columns:auto auto 1fr auto;grid-template-areas:\"expandIcon media main        aside\" \"expandIcon media description aside\";align-items:center;font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase300);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase300);}",
+    ".r1r98egg:active{color:var(--colorNeutralForeground2Pressed);background-color:var(--colorSubtleBackgroundPressed);}",
+    ".r1r98egg:active .fui-TreeItemPersonaLayout__expandIcon{color:var(--colorNeutralForeground3Pressed);}",
+    ".r1r98egg:hover{color:var(--colorNeutralForeground2Hover);background-color:var(--colorSubtleBackgroundHover);}",
+    ".r1r98egg:hover .fui-TreeItemPersonaLayout__expandIcon{color:var(--colorNeutralForeground3Hover);}"
+]);
+/**
+ * Styles for the root slot
+ */ const useRootStyles = /*#__PURE__*/ (0, _react.__styles)({
+    leaf: {
+        uwmqm3: [
+            "f1k1erfc",
+            "faevyjx"
+        ]
+    },
+    branch: {
+        uwmqm3: [
+            "fo100m9",
+            "f6yw3pu"
+        ]
+    },
+    medium: {
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "fkhj508",
+        Bhrd7zp: "figsok6",
+        Bg96gwp: "f1i3iumi"
+    },
+    small: {
+        sshi5w: "f1pha7fy",
+        Bahqtrf: "fk6fouc",
+        Be2twd7: "fy9rknc",
+        Bhrd7zp: "figsok6",
+        Bg96gwp: "fwrc4pm"
+    },
+    subtle: {},
+    "subtle-alpha": {
+        Jwef8y: "f146ro5n",
+        ecr2s2: "fkam630"
+    },
+    transparent: {
+        De3pzq: "f1c21dwh",
+        Jwef8y: "fjxutwb",
+        ecr2s2: "fophhak"
+    }
+}, {
+    d: [
+        ".f1k1erfc{padding-left:calc(var(--fluent-TreeItem--level, 1) * var(--spacingHorizontalXXL));}",
+        ".faevyjx{padding-right:calc(var(--fluent-TreeItem--level, 1) * var(--spacingHorizontalXXL));}",
+        ".fo100m9{padding-left:calc((var(--fluent-TreeItem--level, 1) - 1) * var(--spacingHorizontalXXL));}",
+        ".f6yw3pu{padding-right:calc((var(--fluent-TreeItem--level, 1) - 1) * var(--spacingHorizontalXXL));}",
+        ".fk6fouc{font-family:var(--fontFamilyBase);}",
+        ".fkhj508{font-size:var(--fontSizeBase300);}",
+        ".figsok6{font-weight:var(--fontWeightRegular);}",
+        ".f1i3iumi{line-height:var(--lineHeightBase300);}",
+        ".f1pha7fy{min-height:24px;}",
+        ".fy9rknc{font-size:var(--fontSizeBase200);}",
+        ".fwrc4pm{line-height:var(--lineHeightBase200);}",
+        ".f1c21dwh{background-color:var(--colorTransparentBackground);}"
+    ],
+    h: [
+        ".f146ro5n:hover{background-color:var(--colorSubtleBackgroundLightAlphaHover);}",
+        ".fjxutwb:hover{background-color:var(--colorTransparentBackgroundHover);}"
+    ],
+    a: [
+        ".fkam630:active{background-color:var(--colorSubtleBackgroundLightAlphaPressed);}",
+        ".fophhak:active{background-color:var(--colorTransparentBackgroundPressed);}"
+    ]
+});
+/**
+ * Styles for the expand icon slot
+ */ const useMediaBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rkcde6g", "r1e986zr", [
+    ".rkcde6g{display:flex;align-items:center;width:32px;height:32px;grid-area:media;padding:0 var(--spacingHorizontalXS) 0 var(--spacingHorizontalXXS);}",
+    ".r1e986zr{display:flex;align-items:center;width:32px;height:32px;grid-area:media;padding:0 var(--spacingHorizontalXXS) 0 var(--spacingHorizontalXS);}"
+]);
+const useMainBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1qjtz99", "rob5fcp", [
+    ".r1qjtz99{grid-area:main;padding:var(--spacingVerticalMNudge) var(--spacingHorizontalXS) var(--spacingVerticalMNudge) var(--spacingHorizontalS);}",
+    ".rob5fcp{grid-area:main;padding:var(--spacingVerticalMNudge) var(--spacingHorizontalS) var(--spacingVerticalMNudge) var(--spacingHorizontalXS);}"
+]);
+const useMainStyles = /*#__PURE__*/ (0, _react.__styles)({
+    withDescription: {
+        Byoj8tv: 0,
+        uwmqm3: 0,
+        z189sj: 0,
+        z8tnut: 0,
+        B0ocmuz: [
+            "f1625emv",
+            "f5y9hxg"
+        ]
+    }
+}, {
+    d: [
+        [
+            ".f1625emv{padding:var(--spacingVerticalMNudge) var(--spacingHorizontalXS) 0 var(--spacingHorizontalS);}",
+            {
+                p: -1
+            }
+        ],
+        [
+            ".f5y9hxg{padding:var(--spacingVerticalMNudge) var(--spacingHorizontalS) 0 var(--spacingHorizontalXS);}",
+            {
+                p: -1
+            }
+        ]
+    ]
+});
+const useDescriptionBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1bnsn1b", "r13x7gq", [
+    ".r1bnsn1b{grid-area:description;font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase200);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase200);padding:0 var(--spacingHorizontalXS) var(--spacingVerticalMNudge) var(--spacingHorizontalS);}",
+    ".r13x7gq{grid-area:description;font-family:var(--fontFamilyBase);font-size:var(--fontSizeBase200);font-weight:var(--fontWeightRegular);line-height:var(--lineHeightBase200);padding:0 var(--spacingHorizontalS) var(--spacingVerticalMNudge) var(--spacingHorizontalXS);}"
+]);
+/**
+ * Styles for the action icon slot
+ */ const useActionsBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rzvs2in", "r17h8a29", [
+    ".rzvs2in{display:flex;margin-left:auto;position:relative;z-index:1;grid-area:aside;padding:0 var(--spacingHorizontalS);}",
+    ".r17h8a29{display:flex;margin-right:auto;position:relative;z-index:1;grid-area:aside;padding:0 var(--spacingHorizontalS);}"
+]);
+/**
+ * Styles for the action icon slot
+ */ const useAsideBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("r1825u21", "rezy0yk", [
+    ".r1825u21{display:flex;margin-left:auto;align-items:center;z-index:0;grid-area:aside;padding:0 var(--spacingHorizontalM);gap:var(--spacingHorizontalXS);}",
+    ".rezy0yk{display:flex;margin-right:auto;align-items:center;z-index:0;grid-area:aside;padding:0 var(--spacingHorizontalM);gap:var(--spacingHorizontalXS);}"
+]);
+/**
+ * Styles for the expand icon slot
+ */ const useExpandIconBaseStyles = /*#__PURE__*/ (0, _react.__resetStyles)("rn61xvs", null, [
+    ".rn61xvs{display:flex;align-items:center;justify-content:center;min-width:24px;box-sizing:border-box;color:var(--colorNeutralForeground3);grid-area:expandIcon;flex:0 0 auto;padding:var(--spacingVerticalXS) 0;}"
+]);
+const useTreeItemPersonaLayoutStyles_unstable = (state)=>{
+    'use no memo';
+    const rootBaseStyles = useRootBaseStyles();
+    const rootStyles = useRootStyles();
+    const mediaBaseStyles = useMediaBaseStyles();
+    const descriptionBaseStyles = useDescriptionBaseStyles();
+    const actionsBaseStyles = useActionsBaseStyles();
+    const asideBaseStyles = useAsideBaseStyles();
+    const expandIconBaseStyles = useExpandIconBaseStyles();
+    const mainBaseStyles = useMainBaseStyles();
+    const mainStyles = useMainStyles();
+    const size = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.size);
+    const appearance = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.appearance);
+    const itemType = (0, _treeItemContext.useTreeItemContext_unstable)((ctx)=>ctx.itemType);
+    state.root.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.root, rootBaseStyles, rootStyles[itemType], rootStyles[appearance], rootStyles[size], state.root.className);
+    state.media.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.media, mediaBaseStyles, state.media.className);
+    if (state.main) {
+        state.main.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.main, mainBaseStyles, state.description && mainStyles.withDescription, state.main.className);
+    }
+    if (state.description) {
+        state.description.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.description, descriptionBaseStyles, state.description.className);
+    }
+    if (state.actions) {
+        state.actions.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.actions, actionsBaseStyles, state.actions.className);
+    }
+    if (state.aside) {
+        state.aside.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.aside, asideBaseStyles, state.aside.className);
+    }
+    if (state.expandIcon) {
+        state.expandIcon.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.expandIcon, expandIconBaseStyles, state.expandIcon.className);
+    }
+    if (state.selector) {
+        state.selector.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.selector, state.selector.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeItemPersonaLayout/useTreeItemPersonaLayoutStyles.styles.raw.js

@@ -0,0 +1,192 @@
+'use client';
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    treeItemPersonaLayoutClassNames: function() {
+        return treeItemPersonaLayoutClassNames;
+    },
+    useTreeItemPersonaLayoutStyles_unstable: function() {
+        return useTreeItemPersonaLayoutStyles_unstable;
+    }
+});
+const _react = require("@griffel/react");
+const _reacttheme = require("@fluentui/react-theme");
+const _tokens = require("../../utils/tokens");
+const _treeItemContext = require("../../contexts/treeItemContext");
+const _treeContext = require("../../contexts/treeContext");
+const treeItemPersonaLayoutClassNames = {
+    root: 'fui-TreeItemPersonaLayout',
+    media: 'fui-TreeItemPersonaLayout__media',
+    description: 'fui-TreeItemPersonaLayout__description',
+    main: 'fui-TreeItemPersonaLayout__main',
+    expandIcon: 'fui-TreeItemPersonaLayout__expandIcon',
+    aside: 'fui-TreeItemPersonaLayout__aside',
+    actions: 'fui-TreeItemPersonaLayout__actions',
+    selector: 'fui-TreeItemPersonaLayout__selector'
+};
+const useRootBaseStyles = (0, _react.makeResetStyles)({
+    display: 'grid',
+    gridTemplateRows: '1fr auto',
+    gridTemplateColumns: 'auto auto 1fr auto',
+    gridTemplateAreas: `
+    "expandIcon media main        aside"
+    "expandIcon media description aside"
+  `,
+    alignItems: 'center',
+    ..._reacttheme.typographyStyles.body1,
+    ':active': {
+        color: _reacttheme.tokens.colorNeutralForeground2Pressed,
+        backgroundColor: _reacttheme.tokens.colorSubtleBackgroundPressed,
+        // TODO: stop using treeItemPersonaLayoutClassNames.expandIcon for styling
+        [`& .${treeItemPersonaLayoutClassNames.expandIcon}`]: {
+            color: _reacttheme.tokens.colorNeutralForeground3Pressed
+        }
+    },
+    ':hover': {
+        color: _reacttheme.tokens.colorNeutralForeground2Hover,
+        backgroundColor: _reacttheme.tokens.colorSubtleBackgroundHover,
+        // TODO: stop using treeItemPersonaLayoutClassNames.expandIcon for styling
+        [`& .${treeItemPersonaLayoutClassNames.expandIcon}`]: {
+            color: _reacttheme.tokens.colorNeutralForeground3Hover
+        }
+    }
+});
+/**
+ * Styles for the root slot
+ */ const useRootStyles = (0, _react.makeStyles)({
+    leaf: {
+        paddingLeft: `calc(var(${_tokens.treeItemLevelToken}, 1) * ${_reacttheme.tokens.spacingHorizontalXXL})`
+    },
+    branch: {
+        paddingLeft: `calc((var(${_tokens.treeItemLevelToken}, 1) - 1) * ${_reacttheme.tokens.spacingHorizontalXXL})`
+    },
+    // Size variations
+    medium: {
+        ..._reacttheme.typographyStyles.body1
+    },
+    small: {
+        minHeight: '24px',
+        ..._reacttheme.typographyStyles.caption1
+    },
+    // Appearance variations
+    subtle: {},
+    'subtle-alpha': {
+        ':hover': {
+            backgroundColor: _reacttheme.tokens.colorSubtleBackgroundLightAlphaHover
+        },
+        ':active': {
+            backgroundColor: _reacttheme.tokens.colorSubtleBackgroundLightAlphaPressed
+        }
+    },
+    transparent: {
+        backgroundColor: _reacttheme.tokens.colorTransparentBackground,
+        ':hover': {
+            backgroundColor: _reacttheme.tokens.colorTransparentBackgroundHover
+        },
+        ':active': {
+            backgroundColor: _reacttheme.tokens.colorTransparentBackgroundPressed
+        }
+    }
+});
+/**
+ * Styles for the expand icon slot
+ */ const useMediaBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    alignItems: 'center',
+    width: '32px',
+    height: '32px',
+    gridArea: 'media',
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalXS} 0 ${_reacttheme.tokens.spacingHorizontalXXS}`
+});
+const useMainBaseStyles = (0, _react.makeResetStyles)({
+    gridArea: 'main',
+    padding: `${_reacttheme.tokens.spacingVerticalMNudge} ${_reacttheme.tokens.spacingHorizontalXS} ${_reacttheme.tokens.spacingVerticalMNudge} ${_reacttheme.tokens.spacingHorizontalS}`
+});
+const useMainStyles = (0, _react.makeStyles)({
+    withDescription: {
+        padding: `${_reacttheme.tokens.spacingVerticalMNudge} ${_reacttheme.tokens.spacingHorizontalXS} 0 ${_reacttheme.tokens.spacingHorizontalS}`
+    }
+});
+const useDescriptionBaseStyles = (0, _react.makeResetStyles)({
+    gridArea: 'description',
+    ..._reacttheme.typographyStyles.caption1,
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalXS} ${_reacttheme.tokens.spacingVerticalMNudge} ${_reacttheme.tokens.spacingHorizontalS}`
+});
+/**
+ * Styles for the action icon slot
+ */ const useActionsBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    marginLeft: 'auto',
+    position: 'relative',
+    zIndex: 1,
+    gridArea: 'aside',
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalS}`
+});
+/**
+ * Styles for the action icon slot
+ */ const useAsideBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    marginLeft: 'auto',
+    alignItems: 'center',
+    zIndex: 0,
+    gridArea: 'aside',
+    padding: `0 ${_reacttheme.tokens.spacingHorizontalM}`,
+    gap: _reacttheme.tokens.spacingHorizontalXS
+});
+/**
+ * Styles for the expand icon slot
+ */ const useExpandIconBaseStyles = (0, _react.makeResetStyles)({
+    display: 'flex',
+    alignItems: 'center',
+    justifyContent: 'center',
+    minWidth: '24px',
+    boxSizing: 'border-box',
+    color: _reacttheme.tokens.colorNeutralForeground3,
+    gridArea: 'expandIcon',
+    flex: `0 0 auto`,
+    padding: `${_reacttheme.tokens.spacingVerticalXS} 0`
+});
+const useTreeItemPersonaLayoutStyles_unstable = (state)=>{
+    'use no memo';
+    const rootBaseStyles = useRootBaseStyles();
+    const rootStyles = useRootStyles();
+    const mediaBaseStyles = useMediaBaseStyles();
+    const descriptionBaseStyles = useDescriptionBaseStyles();
+    const actionsBaseStyles = useActionsBaseStyles();
+    const asideBaseStyles = useAsideBaseStyles();
+    const expandIconBaseStyles = useExpandIconBaseStyles();
+    const mainBaseStyles = useMainBaseStyles();
+    const mainStyles = useMainStyles();
+    const size = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.size);
+    const appearance = (0, _treeContext.useTreeContext_unstable)((ctx)=>ctx.appearance);
+    const itemType = (0, _treeItemContext.useTreeItemContext_unstable)((ctx)=>ctx.itemType);
+    state.root.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.root, rootBaseStyles, rootStyles[itemType], rootStyles[appearance], rootStyles[size], state.root.className);
+    state.media.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.media, mediaBaseStyles, state.media.className);
+    if (state.main) {
+        state.main.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.main, mainBaseStyles, state.description && mainStyles.withDescription, state.main.className);
+    }
+    if (state.description) {
+        state.description.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.description, descriptionBaseStyles, state.description.className);
+    }
+    if (state.actions) {
+        state.actions.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.actions, actionsBaseStyles, state.actions.className);
+    }
+    if (state.aside) {
+        state.aside.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.aside, asideBaseStyles, state.aside.className);
+    }
+    if (state.expandIcon) {
+        state.expandIcon.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.expandIcon, expandIconBaseStyles, state.expandIcon.className);
+    }
+    if (state.selector) {
+        state.selector.className = (0, _react.mergeClasses)(treeItemPersonaLayoutClassNames.selector, state.selector.className);
+    }
+    return state;
+};

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeProvider.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    TreeProvider: function() {
+        return TreeProvider;
+    },
+    TreeRootReset: function() {
+        return TreeRootReset;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
+const _contexts = require("../contexts");
+/**
+ * @internal
+ */ const rootSubtreeContextValue = {
+    level: 1,
+    contextType: 'subtree'
+};
+const TreeProvider = (props)=>{
+    if (props.value.contextType === 'subtree') {
+        return /*#__PURE__*/ _react.createElement(_contexts.SubtreeContext.Provider, {
+            value: props.value
+        }, props.children);
+    }
+    return /*#__PURE__*/ _react.createElement(_contexts.TreeContext.Provider, {
+        value: props.value
+    }, /*#__PURE__*/ _react.createElement(_contexts.SubtreeContext.Provider, {
+        value: rootSubtreeContextValue
+    }, props.children));
+};
+TreeProvider.displayName = 'TreeProvider';
+const TreeRootReset = (props)=>/*#__PURE__*/ _react.createElement(_contexts.SubtreeContext.Provider, {
+        value: undefined
+    }, props.children);

node_modules/@fluentui/react-tree/lib-commonjs/components/TreeProvider.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/components/TreeProvider.tsx"],"sourcesContent":["import * as React from 'react';\nimport { SubtreeContext, SubtreeContextValue, TreeContextValue, TreeContext } from '../contexts';\nimport type { JSXElement } from '@fluentui/react-utilities';\n\n/**\n * @internal\n */\nconst rootSubtreeContextValue: SubtreeContextValue = {\n  level: 1,\n  contextType: 'subtree',\n};\nexport const TreeProvider = (props: React.ProviderProps<TreeContextValue | SubtreeContextValue>): JSXElement => {\n  if (props.value.contextType === 'subtree') {\n    return <SubtreeContext.Provider value={props.value}>{props.children}</SubtreeContext.Provider>;\n  }\n  return (\n    <TreeContext.Provider value={props.value}>\n      <SubtreeContext.Provider value={rootSubtreeContextValue}>{props.children}</SubtreeContext.Provider>\n    </TreeContext.Provider>\n  );\n};\n\nTreeProvider.displayName = 'TreeProvider';\n\nexport type TreeRootResetProps = {\n  children?: React.ReactNode;\n};\nexport const TreeRootReset = (props: TreeRootResetProps): JSXElement => (\n  <SubtreeContext.Provider value={undefined as unknown as SubtreeContextValue}>\n    {props.children}\n  </SubtreeContext.Provider>\n);\n"],"names":["React","SubtreeContext","TreeContext","rootSubtreeContextValue","level","contextType","TreeProvider","props","value","Provider","children","displayName","TreeRootReset","undefined"],"mappings":";;;;;;;;;;;IAWaM,YAAAA;;;iBAgBAM;;;;;iEA3BU,QAAQ;0BACoD,cAAc;AAGjG;;CAEC,GACD,MAAMT,0BAA+C;IACnDC,OAAO;IACPC,aAAa;AACf;AACO,qBAAqB,CAACE;IAC3B,IAAIA,MAAMC,KAAK,CAACH,WAAW,KAAK,WAAW;QACzC,OAAA,WAAA,GAAO,OAAA,aAAA,CAACJ,wBAAAA,CAAeQ,QAAQ,EAAA;YAACD,OAAOD,MAAMC,KAAK;WAAGD,MAAMG,QAAQ;IACrE;IACA,OAAA,WAAA,GACE,OAAA,aAAA,CAACR,qBAAAA,CAAYO,QAAQ,EAAA;QAACD,OAAOD,MAAMC,KAAK;qBACtC,OAAA,aAAA,CAACP,wBAAAA,CAAeQ,QAAQ,EAAA;QAACD,OAAOL;OAA0BI,MAAMG,QAAQ;AAG9E,EAAE;AAEFJ,aAAaK,WAAW,GAAG;AAKpB,MAAMC,gBAAgB,CAACL,QAAAA,WAAAA,GAC5B,OAAA,aAAA,CAACN,wBAAAA,CAAeQ,QAAQ,EAAA;QAACD,OAAOK;OAC7BN,MAAMG,QAAQ,EAEjB"}