@fluentui/react-tree 9.7.7 → 9.7.8

package/lib-commonjs/components/Tree/useNestedControllableCheckedItems.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useNestedControllableCheckedItems.ts"],"sourcesContent":["import * 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(props: Pick<TreeProps, 'checkedItems'>) {\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.create([[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":["createNextNestedCheckedItems","useNestedCheckedItems","props","React","useMemo","createCheckedItems","checkedItems","data","previousCheckedItems","selectionMode","ImmutableMap","create","value","checked","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAUgBA,4BAAAA;eAAAA;;IAJAC,qBAAAA;eAAAA;;;;iEANO;8BAEM;oCACM;AAG5B,SAASA,sBAAsBC,KAAsC;IAC1E,OAAOC,OAAMC,OAAO,CAAC,IAAMC,IAAAA,sCAAAA,EAAmBH,MAAMI,YAAY,GAAG;QAACJ,MAAMI,YAAY;KAAC;AACzF;AAEO,SAASN,6BACdO,IAAwE,EACxEC,oBAAoE;IAEpE,IAAID,KAAKE,aAAa,KAAK,UAAU;QACnC,OAAOC,0BAAAA,CAAaC,MAAM,CAAC;YAAC;gBAACJ,KAAKK,KAAK;gBAAEL,KAAKM,OAAO;aAAC;SAAC;IACzD;IACA,IAAIN,KAAKE,aAAa,KAAK,eAAe;QACxC,OAAOD,qBAAqBM,GAAG,CAACP,KAAKK,KAAK,EAAEL,KAAKM,OAAO;IAC1D;IACA,OAAOL;AACT"}
+{"version":3,"sources":["useNestedControllableCheckedItems.ts"],"sourcesContent":["import * 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(props: Pick<TreeProps, 'checkedItems'>) {\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":["createNextNestedCheckedItems","useNestedCheckedItems","props","React","useMemo","createCheckedItems","checkedItems","data","previousCheckedItems","selectionMode","ImmutableMap","from","value","checked","set"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAUgBA,4BAAAA;eAAAA;;IAJAC,qBAAAA;eAAAA;;;;iEANO;8BAEM;oCACM;AAG5B,SAASA,sBAAsBC,KAAsC;IAC1E,OAAOC,OAAMC,OAAO,CAAC,IAAMC,IAAAA,sCAAAA,EAAmBH,MAAMI,YAAY,GAAG;QAACJ,MAAMI,YAAY;KAAC;AACzF;AAEO,SAASN,6BACdO,IAAwE,EACxEC,oBAAoE;IAEpE,IAAID,KAAKE,aAAa,KAAK,UAAU;QACnC,OAAOC,0BAAAA,CAAaC,IAAI,CAAC;YAAC;gBAACJ,KAAKK,KAAK;gBAAEL,KAAKM,OAAO;aAAC;SAAC;IACvD;IACA,IAAIN,KAAKE,aAAa,KAAK,eAAe;QACxC,OAAOD,qBAAqBM,GAAG,CAACP,KAAKK,KAAK,EAAEL,KAAKM,OAAO;IAC1D;IACA,OAAOL;AACT"}

package/lib-commonjs/components/Tree/useTree.js

@@ -18,6 +18,8 @@ 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;
@@ -40,7 +42,7 @@ function useNestedRootTree(props, ref) {
             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: nextOpenItems.dangerouslyGetInternalSet_unstable()
+                openItems: _ImmutableSet.ImmutableSet.dangerouslyGetInternalSet(nextOpenItems)
             });
             setOpenItems(nextOpenItems);
         }),
@@ -58,7 +60,7 @@ function useNestedRootTree(props, ref) {
             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: nextCheckedItems.dangerouslyGetInternalMap_unstable()
+                checkedItems: _ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(nextCheckedItems)
             });
         })
     }, (0, _reactutilities.useMergedRefs)(ref, navigation.treeRef)), {

package/lib-commonjs/components/Tree/useTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useTree.ts"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport type { TreeProps, TreeState } from './Tree.types';\nimport { createNextOpenItems, useControllableOpenItems } from '../../hooks/useControllableOpenItems';\nimport { createNextNestedCheckedItems, useNestedCheckedItems } from './useNestedControllableCheckedItems';\nimport { SubtreeContext } from '../../contexts/subtreeContext';\nimport { useRootTree } from '../../hooks/useRootTree';\nimport { useSubtree } from '../../hooks/useSubtree';\nimport { useTreeNavigation } from '../../hooks/useTreeNavigation';\nimport { useTreeContext_unstable } from '../../contexts/treeContext';\n\nexport const useTree_unstable = (props: TreeProps, ref: React.Ref<HTMLElement>): TreeState => {\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 ? useNestedRootTree(props, ref) : useNestedSubtree(props, ref);\n};\n\nfunction useNestedRootTree(props: TreeProps, ref: React.Ref<HTMLElement>): TreeState {\n  'use no memo';\n\n  const [openItems, setOpenItems] = useControllableOpenItems(props);\n  const checkedItems = useNestedCheckedItems(props);\n  const navigation = useTreeNavigation();\n\n  return Object.assign(\n    useRootTree(\n      {\n        ...props,\n        openItems,\n        checkedItems,\n        onOpenChange: useEventCallback((event, data) => {\n          const nextOpenItems = createNextOpenItems(data, openItems);\n          props.onOpenChange?.(event, {\n            ...data,\n            openItems: nextOpenItems.dangerouslyGetInternalSet_unstable(),\n          });\n          setOpenItems(nextOpenItems);\n        }),\n        onNavigation: useEventCallback((event, data) => {\n          props.onNavigation?.(event, data);\n          if (!event.isDefaultPrevented()) {\n            navigation.navigate(data, {\n              preventScroll: data.isScrollPrevented(),\n            });\n          }\n        }),\n        onCheckedChange: useEventCallback((event, data) => {\n          const nextCheckedItems = createNextNestedCheckedItems(data, checkedItems);\n          props.onCheckedChange?.(event, {\n            ...data,\n            checkedItems: nextCheckedItems.dangerouslyGetInternalMap_unstable(),\n          });\n        }),\n      },\n      useMergedRefs(ref, navigation.treeRef),\n    ),\n    { treeType: 'nested' } as const,\n  );\n}\n\nfunction useNestedSubtree(props: TreeProps, ref: React.Ref<HTMLElement>): TreeState {\n  'use no memo';\n\n  if (process.env.NODE_ENV === 'development') {\n    // this doesn't break rule of hooks, as environment is a static value\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const treeType = useTreeContext_unstable(ctx => ctx.treeType);\n    if (treeType === 'flat') {\n      throw new Error(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useTree]:\n        Subtrees are not allowed in a FlatTree!\n        You cannot use a <Tree> component inside of a <FlatTree> component!\n      `);\n    }\n  }\n  return useSubtree(props, ref);\n}\n"],"names":["useTree_unstable","props","ref","isRoot","React","useContext","SubtreeContext","undefined","useNestedRootTree","useNestedSubtree","openItems","setOpenItems","useControllableOpenItems","checkedItems","useNestedCheckedItems","navigation","useTreeNavigation","Object","assign","useRootTree","onOpenChange","useEventCallback","event","data","nextOpenItems","createNextOpenItems","dangerouslyGetInternalSet_unstable","onNavigation","isDefaultPrevented","navigate","preventScroll","isScrollPrevented","onCheckedChange","nextCheckedItems","createNextNestedCheckedItems","dangerouslyGetInternalMap_unstable","useMergedRefs","treeRef","treeType","process","env","NODE_ENV","useTreeContext_unstable","ctx","Error","useSubtree"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAWaA;;;eAAAA;;;;iEAXU;gCACyB;0CAEc;mDACM;gCACrC;6BACH;4BACD;mCACO;6BACM;AAEjC,MAAMA,mBAAmB,CAACC,OAAkBC;IACjD;IAEA,MAAMC,SAASC,OAAMC,UAAU,CAACC,8BAAAA,MAAoBC;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOJ,SAASK,kBAAkBP,OAAOC,OAAOO,iBAAiBR,OAAOC;AAC1E;AAEA,SAASM,kBAAkBP,KAAgB,EAAEC,GAA2B;IACtE;IAEA,MAAM,CAACQ,WAAWC,aAAa,GAAGC,IAAAA,kDAAAA,EAAyBX;IAC3D,MAAMY,eAAeC,IAAAA,wDAAAA,EAAsBb;IAC3C,MAAMc,aAAaC,IAAAA,oCAAAA;IAEnB,OAAOC,OAAOC,MAAM,CAClBC,IAAAA,wBAAAA,EACE;QACE,GAAGlB,KAAK;QACRS;QACAG;QACAO,cAAcC,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBAErCtB;YADA,MAAMuB,gBAAgBC,IAAAA,6CAAAA,EAAoBF,MAAMb;YAChDT,CAAAA,sBAAAA,MAAMmB,YAAY,AAAZA,MAAY,QAAlBnB,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBqB,OAAO;gBAC1B,GAAGC,IAAI;gBACPb,WAAWc,cAAcE,kCAAkC;YAC7D;YACAf,aAAaa;QACf;QACAG,cAAcN,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBACrCtB;YAAAA,CAAAA,sBAAAA,MAAM0B,YAAY,AAAZA,MAAY,QAAlB1B,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBqB,OAAOC;YAC5B,IAAI,CAACD,MAAMM,kBAAkB,IAAI;gBAC/Bb,WAAWc,QAAQ,CAACN,MAAM;oBACxBO,eAAeP,KAAKQ,iBAAiB;gBACvC;YACF;QACF;QACAC,iBAAiBX,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBAExCtB;YADA,MAAMgC,mBAAmBC,IAAAA,+DAAAA,EAA6BX,MAAMV;YAC5DZ,CAAAA,yBAAAA,MAAM+B,eAAe,AAAfA,MAAe,QAArB/B,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAAA,IAAAA,CAAAA,OAAwBqB,OAAO;gBAC7B,GAAGC,IAAI;gBACPV,cAAcoB,iBAAiBE,kCAAkC;YACnE;QACF;IACF,GACAC,IAAAA,6BAAAA,EAAclC,KAAKa,WAAWsB,OAAO,IAEvC;QAAEC,UAAU;IAAS;AAEzB;AAEA,SAAS7B,iBAAiBR,KAAgB,EAAEC,GAA2B;IACrE;IAEA,IAAIqC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,qEAAqE;QACrE,sDAAsD;QACtD,MAAMH,WAAWI,IAAAA,oCAAAA,EAAwBC,CAAAA,MAAOA,IAAIL,QAAQ;QAC5D,IAAIA,aAAa,QAAQ;YACvB,MAAM,IAAIM,MAA2B,CAAC;;mEAItC,CAAC;QACH;IACF;IACA,OAAOC,IAAAA,sBAAAA,EAAW5C,OAAOC;AAC3B"}
+{"version":3,"sources":["useTree.ts"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport type { TreeProps, TreeState } from './Tree.types';\nimport { createNextOpenItems, useControllableOpenItems } from '../../hooks/useControllableOpenItems';\nimport { createNextNestedCheckedItems, useNestedCheckedItems } from './useNestedControllableCheckedItems';\nimport { SubtreeContext } from '../../contexts/subtreeContext';\nimport { useRootTree } from '../../hooks/useRootTree';\nimport { useSubtree } from '../../hooks/useSubtree';\nimport { useTreeNavigation } from '../../hooks/useTreeNavigation';\nimport { useTreeContext_unstable } from '../../contexts/treeContext';\nimport { ImmutableSet } from '../../utils/ImmutableSet';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\n\nexport const useTree_unstable = (props: TreeProps, ref: React.Ref<HTMLElement>): TreeState => {\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 ? useNestedRootTree(props, ref) : useNestedSubtree(props, ref);\n};\n\nfunction useNestedRootTree(props: TreeProps, ref: React.Ref<HTMLElement>): TreeState {\n  'use no memo';\n\n  const [openItems, setOpenItems] = useControllableOpenItems(props);\n  const checkedItems = useNestedCheckedItems(props);\n  const navigation = useTreeNavigation();\n\n  return Object.assign(\n    useRootTree(\n      {\n        ...props,\n        openItems,\n        checkedItems,\n        onOpenChange: useEventCallback((event, data) => {\n          const nextOpenItems = createNextOpenItems(data, openItems);\n          props.onOpenChange?.(event, {\n            ...data,\n            openItems: ImmutableSet.dangerouslyGetInternalSet(nextOpenItems),\n          });\n          setOpenItems(nextOpenItems);\n        }),\n        onNavigation: useEventCallback((event, data) => {\n          props.onNavigation?.(event, data);\n          if (!event.isDefaultPrevented()) {\n            navigation.navigate(data, {\n              preventScroll: data.isScrollPrevented(),\n            });\n          }\n        }),\n        onCheckedChange: useEventCallback((event, data) => {\n          const nextCheckedItems = createNextNestedCheckedItems(data, checkedItems);\n          props.onCheckedChange?.(event, {\n            ...data,\n            checkedItems: ImmutableMap.dangerouslyGetInternalMap(nextCheckedItems),\n          });\n        }),\n      },\n      useMergedRefs(ref, navigation.treeRef),\n    ),\n    { treeType: 'nested' } as const,\n  );\n}\n\nfunction useNestedSubtree(props: TreeProps, ref: React.Ref<HTMLElement>): TreeState {\n  'use no memo';\n\n  if (process.env.NODE_ENV === 'development') {\n    // this doesn't break rule of hooks, as environment is a static value\n    // eslint-disable-next-line react-hooks/rules-of-hooks\n    const treeType = useTreeContext_unstable(ctx => ctx.treeType);\n    if (treeType === 'flat') {\n      throw new Error(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useTree]:\n        Subtrees are not allowed in a FlatTree!\n        You cannot use a <Tree> component inside of a <FlatTree> component!\n      `);\n    }\n  }\n  return useSubtree(props, ref);\n}\n"],"names":["useTree_unstable","props","ref","isRoot","React","useContext","SubtreeContext","undefined","useNestedRootTree","useNestedSubtree","openItems","setOpenItems","useControllableOpenItems","checkedItems","useNestedCheckedItems","navigation","useTreeNavigation","Object","assign","useRootTree","onOpenChange","useEventCallback","event","data","nextOpenItems","createNextOpenItems","ImmutableSet","dangerouslyGetInternalSet","onNavigation","isDefaultPrevented","navigate","preventScroll","isScrollPrevented","onCheckedChange","nextCheckedItems","createNextNestedCheckedItems","ImmutableMap","dangerouslyGetInternalMap","useMergedRefs","treeRef","treeType","process","env","NODE_ENV","useTreeContext_unstable","ctx","Error","useSubtree"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAaaA;;;eAAAA;;;;iEAbU;gCACyB;0CAEc;mDACM;gCACrC;6BACH;4BACD;mCACO;6BACM;8BACX;8BACA;AAEtB,MAAMA,mBAAmB,CAACC,OAAkBC;IACjD;IAEA,MAAMC,SAASC,OAAMC,UAAU,CAACC,8BAAAA,MAAoBC;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOJ,SAASK,kBAAkBP,OAAOC,OAAOO,iBAAiBR,OAAOC;AAC1E;AAEA,SAASM,kBAAkBP,KAAgB,EAAEC,GAA2B;IACtE;IAEA,MAAM,CAACQ,WAAWC,aAAa,GAAGC,IAAAA,kDAAAA,EAAyBX;IAC3D,MAAMY,eAAeC,IAAAA,wDAAAA,EAAsBb;IAC3C,MAAMc,aAAaC,IAAAA,oCAAAA;IAEnB,OAAOC,OAAOC,MAAM,CAClBC,IAAAA,wBAAAA,EACE;QACE,GAAGlB,KAAK;QACRS;QACAG;QACAO,cAAcC,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBAErCtB;YADA,MAAMuB,gBAAgBC,IAAAA,6CAAAA,EAAoBF,MAAMb;YAChDT,CAAAA,sBAAAA,MAAMmB,YAAY,AAAZA,MAAY,QAAlBnB,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBqB,OAAO;gBAC1B,GAAGC,IAAI;gBACPb,WAAWgB,0BAAAA,CAAaC,yBAAyB,CAACH;YACpD;YACAb,aAAaa;QACf;QACAI,cAAcP,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBACrCtB;YAAAA,CAAAA,sBAAAA,MAAM2B,YAAY,AAAZA,MAAY,QAAlB3B,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBqB,OAAOC;YAC5B,IAAI,CAACD,MAAMO,kBAAkB,IAAI;gBAC/Bd,WAAWe,QAAQ,CAACP,MAAM;oBACxBQ,eAAeR,KAAKS,iBAAiB;gBACvC;YACF;QACF;QACAC,iBAAiBZ,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBAExCtB;YADA,MAAMiC,mBAAmBC,IAAAA,+DAAAA,EAA6BZ,MAAMV;YAC5DZ,CAAAA,yBAAAA,MAAMgC,eAAe,AAAfA,MAAe,QAArBhC,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAAA,IAAAA,CAAAA,OAAwBqB,OAAO;gBAC7B,GAAGC,IAAI;gBACPV,cAAcuB,0BAAAA,CAAaC,yBAAyB,CAACH;YACvD;QACF;IACF,GACAI,IAAAA,6BAAAA,EAAcpC,KAAKa,WAAWwB,OAAO,IAEvC;QAAEC,UAAU;IAAS;AAEzB;AAEA,SAAS/B,iBAAiBR,KAAgB,EAAEC,GAA2B;IACrE;IAEA,IAAIuC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,qEAAqE;QACrE,sDAAsD;QACtD,MAAMH,WAAWI,IAAAA,oCAAAA,EAAwBC,CAAAA,MAAOA,IAAIL,QAAQ;QAC5D,IAAIA,aAAa,QAAQ;YACvB,MAAM,IAAIM,MAA2B,CAAC;;mEAItC,CAAC;QACH;IACF;IACA,OAAOC,IAAAA,sBAAAA,EAAW9C,OAAOC;AAC3B"}

package/lib-commonjs/hooks/useControllableOpenItems.js

@@ -20,24 +20,15 @@ const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildc
 const _reactutilities = require("@fluentui/react-utilities");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _ImmutableSet = require("../utils/ImmutableSet");
-const _createOpenItems = require("../utils/createOpenItems");
 function useControllableOpenItems(props) {
     return (0, _reactutilities.useControllableState)({
-        state: _react.useMemo(()=>props.openItems && (0, _createOpenItems.createOpenItems)(props.openItems), [
+        state: _react.useMemo(()=>props.openItems && _ImmutableSet.ImmutableSet.from(props.openItems), [
             props.openItems
         ]),
-        defaultState: props.defaultOpenItems && (()=>(0, _createOpenItems.createOpenItems)(props.defaultOpenItems)),
+        defaultState: props.defaultOpenItems && (()=>_ImmutableSet.ImmutableSet.from(props.defaultOpenItems)),
         initialState: _ImmutableSet.ImmutableSet.empty
     });
 }
 function createNextOpenItems(data, previousOpenItems) {
-    if (data.value === null) {
-        return previousOpenItems;
-    }
-    const previousOpenItemsHasId = previousOpenItems.has(data.value);
-    if (data.open ? previousOpenItemsHasId : !previousOpenItemsHasId) {
-        return previousOpenItems;
-    }
-    const nextOpenItems = _ImmutableSet.ImmutableSet.create(previousOpenItems);
-    return data.open ? nextOpenItems.add(data.value) : nextOpenItems.delete(data.value);
+    return data.open ? previousOpenItems.add(data.value) : previousOpenItems.delete(data.value);
 }

package/lib-commonjs/hooks/useControllableOpenItems.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useControllableOpenItems.ts"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { ImmutableSet } from '../utils/ImmutableSet';\nimport type { TreeItemValue } from '../components/TreeItem/TreeItem.types';\nimport { createOpenItems } from '../utils/createOpenItems';\nimport { TreeOpenChangeData, TreeProps } from '../Tree';\n\n/**\n * @internal\n */\nexport function useControllableOpenItems(props: Pick<TreeProps, 'openItems' | 'defaultOpenItems'>) {\n  return useControllableState({\n    state: React.useMemo(() => props.openItems && createOpenItems(props.openItems), [props.openItems]),\n    defaultState: props.defaultOpenItems && (() => createOpenItems(props.defaultOpenItems)),\n    initialState: ImmutableSet.empty,\n  });\n}\n\n/**\n * @internal\n */\nexport function createNextOpenItems(\n  data: Pick<TreeOpenChangeData, 'value' | 'open'>,\n  previousOpenItems: ImmutableSet<TreeItemValue>,\n): ImmutableSet<TreeItemValue> {\n  if (data.value === null) {\n    return previousOpenItems;\n  }\n  const previousOpenItemsHasId = previousOpenItems.has(data.value);\n  if (data.open ? previousOpenItemsHasId : !previousOpenItemsHasId) {\n    return previousOpenItems;\n  }\n  const nextOpenItems = ImmutableSet.create(previousOpenItems);\n  return data.open ? nextOpenItems.add(data.value) : nextOpenItems.delete(data.value);\n}\n"],"names":["createNextOpenItems","useControllableOpenItems","props","useControllableState","state","React","useMemo","openItems","createOpenItems","defaultState","defaultOpenItems","initialState","ImmutableSet","empty","data","previousOpenItems","value","previousOpenItemsHasId","has","open","nextOpenItems","create","add","delete"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAqBgBA,mBAAAA;eAAAA;;IAXAC,wBAAAA;eAAAA;;;;gCAVqB;iEACd;8BACM;iCAEG;AAMzB,SAASA,yBAAyBC,KAAwD;IAC/F,OAAOC,IAAAA,oCAAAA,EAAqB;QAC1BC,OAAOC,OAAMC,OAAO,CAAC,IAAMJ,MAAMK,SAAS,IAAIC,IAAAA,gCAAAA,EAAgBN,MAAMK,SAAS,GAAG;YAACL,MAAMK,SAAS;SAAC;QACjGE,cAAcP,MAAMQ,gBAAgB,IAAK,CAAA,IAAMF,IAAAA,gCAAAA,EAAgBN,MAAMQ,gBAAgB,CAAA;QACrFC,cAAcC,0BAAAA,CAAaC,KAAK;IAClC;AACF;AAKO,SAASb,oBACdc,IAAgD,EAChDC,iBAA8C;IAE9C,IAAID,KAAKE,KAAK,KAAK,MAAM;QACvB,OAAOD;IACT;IACA,MAAME,yBAAyBF,kBAAkBG,GAAG,CAACJ,KAAKE,KAAK;IAC/D,IAAIF,KAAKK,IAAI,GAAGF,yBAAyB,CAACA,wBAAwB;QAChE,OAAOF;IACT;IACA,MAAMK,gBAAgBR,0BAAAA,CAAaS,MAAM,CAACN;IAC1C,OAAOD,KAAKK,IAAI,GAAGC,cAAcE,GAAG,CAACR,KAAKE,KAAK,IAAII,cAAcG,MAAM,CAACT,KAAKE,KAAK;AACpF"}
+{"version":3,"sources":["useControllableOpenItems.ts"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { ImmutableSet } from '../utils/ImmutableSet';\nimport type { TreeItemValue } from '../components/TreeItem/TreeItem.types';\nimport { TreeOpenChangeData, TreeProps } from '../Tree';\n\n/**\n * @internal\n */\nexport function useControllableOpenItems(props: Pick<TreeProps, 'openItems' | 'defaultOpenItems'>) {\n  return useControllableState({\n    state: React.useMemo(() => props.openItems && ImmutableSet.from(props.openItems), [props.openItems]),\n    defaultState: props.defaultOpenItems && (() => ImmutableSet.from(props.defaultOpenItems)),\n    initialState: ImmutableSet.empty,\n  });\n}\n\n/**\n * @internal\n */\nexport function createNextOpenItems(\n  data: Pick<TreeOpenChangeData, 'value' | 'open'>,\n  previousOpenItems: ImmutableSet<TreeItemValue>,\n): ImmutableSet<TreeItemValue> {\n  return data.open ? previousOpenItems.add(data.value) : previousOpenItems.delete(data.value);\n}\n"],"names":["createNextOpenItems","useControllableOpenItems","props","useControllableState","state","React","useMemo","openItems","ImmutableSet","from","defaultState","defaultOpenItems","initialState","empty","data","previousOpenItems","open","add","value","delete"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAoBgBA,mBAAAA;eAAAA;;IAXAC,wBAAAA;eAAAA;;;;gCATqB;iEACd;8BACM;AAOtB,SAASA,yBAAyBC,KAAwD;IAC/F,OAAOC,IAAAA,oCAAAA,EAAqB;QAC1BC,OAAOC,OAAMC,OAAO,CAAC,IAAMJ,MAAMK,SAAS,IAAIC,0BAAAA,CAAaC,IAAI,CAACP,MAAMK,SAAS,GAAG;YAACL,MAAMK,SAAS;SAAC;QACnGG,cAAcR,MAAMS,gBAAgB,IAAK,CAAA,IAAMH,0BAAAA,CAAaC,IAAI,CAACP,MAAMS,gBAAgB,CAAA;QACvFC,cAAcJ,0BAAAA,CAAaK,KAAK;IAClC;AACF;AAKO,SAASb,oBACdc,IAAgD,EAChDC,iBAA8C;IAE9C,OAAOD,KAAKE,IAAI,GAAGD,kBAAkBE,GAAG,CAACH,KAAKI,KAAK,IAAIH,kBAAkBI,MAAM,CAACL,KAAKI,KAAK;AAC5F"}

package/lib-commonjs/hooks/useRootTree.js

@@ -12,14 +12,15 @@ const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildc
 const _reactutilities = require("@fluentui/react-utilities");
 const _react = /*#__PURE__*/ _interop_require_wildcard._(require("react"));
 const _reactmotioncomponentspreview = require("@fluentui/react-motion-components-preview");
-const _createOpenItems = require("../utils/createOpenItems");
 const _createCheckedItems = require("../utils/createCheckedItems");
 const _tokens = require("../utils/tokens");
 const _useControllableOpenItems = require("./useControllableOpenItems");
+const _ImmutableSet = require("../utils/ImmutableSet");
+const _ImmutableMap = require("../utils/ImmutableMap");
 function useRootTree(props, ref) {
     warnIfNoProperPropsRootTree(props);
     const { appearance = 'subtle', size = 'medium', selectionMode = 'none' } = props;
-    const openItems = _react.useMemo(()=>(0, _createOpenItems.createOpenItems)(props.openItems), [
+    const openItems = _react.useMemo(()=>_ImmutableSet.ImmutableSet.from(props.openItems), [
         props.openItems
     ]);
     const checkedItems = _react.useMemo(()=>(0, _createCheckedItems.createCheckedItems)(props.checkedItems), [
@@ -29,7 +30,7 @@ function useRootTree(props, ref) {
         var _props_onOpenChange;
         (_props_onOpenChange = props.onOpenChange) === null || _props_onOpenChange === void 0 ? void 0 : _props_onOpenChange.call(props, request.event, {
             ...request,
-            openItems: (0, _useControllableOpenItems.createNextOpenItems)(request, openItems).dangerouslyGetInternalSet_unstable()
+            openItems: _ImmutableSet.ImmutableSet.dangerouslyGetInternalSet((0, _useControllableOpenItems.createNextOpenItems)(request, openItems))
         });
     };
     const requestCheckedChange = (request)=>{
@@ -40,7 +41,7 @@ function useRootTree(props, ref) {
         (_props_onCheckedChange = props.onCheckedChange) === null || _props_onCheckedChange === void 0 ? void 0 : _props_onCheckedChange.call(props, request.event, {
             ...request,
             selectionMode,
-            checkedItems: checkedItems.dangerouslyGetInternalMap_unstable()
+            checkedItems: _ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(checkedItems)
         });
     };
     const requestNavigation = (request)=>{

package/lib-commonjs/hooks/useRootTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useRootTree.ts"],"sourcesContent":["import { getIntrinsicElementProps, useEventCallback, slot } from '@fluentui/react-utilities';\nimport type { TreeCheckedChangeData, TreeProps, TreeState } from '../Tree';\nimport * as React from 'react';\nimport { Collapse } from '@fluentui/react-motion-components-preview';\nimport { PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport { TreeContextValue, TreeItemRequest } from '../contexts/treeContext';\nimport { createOpenItems } from '../utils/createOpenItems';\nimport { createCheckedItems } from '../utils/createCheckedItems';\nimport { treeDataTypes } from '../utils/tokens';\nimport { createNextOpenItems } from './useControllableOpenItems';\n\n/**\n * Create the state required to render the root level tree.\n *\n * @param props - props from this instance of tree\n * @param ref - reference to root HTMLElement of tree\n */\nexport function useRootTree(\n  props: TreeProps,\n  ref: React.Ref<HTMLElement>,\n): Omit<TreeState & TreeContextValue, 'treeType'> {\n  warnIfNoProperPropsRootTree(props);\n\n  const { appearance = 'subtle', size = 'medium', selectionMode = 'none' } = props;\n\n  const openItems = React.useMemo(() => createOpenItems(props.openItems), [props.openItems]);\n  const checkedItems = React.useMemo(() => createCheckedItems(props.checkedItems), [props.checkedItems]);\n\n  const requestOpenChange = (request: Extract<TreeItemRequest, { requestType: 'open' }>) => {\n    props.onOpenChange?.(request.event, {\n      ...request,\n      openItems: createNextOpenItems(request, openItems).dangerouslyGetInternalSet_unstable(),\n    });\n  };\n\n  const requestCheckedChange = (request: Extract<TreeItemRequest, { requestType: 'selection' }>) => {\n    if (selectionMode === 'none') {\n      return;\n    }\n    props.onCheckedChange?.(request.event, {\n      ...request,\n      selectionMode,\n      checkedItems: checkedItems.dangerouslyGetInternalMap_unstable(),\n      // Casting is required here due to selection | multiselection spreading the union problem\n    } as TreeCheckedChangeData);\n  };\n\n  const requestNavigation = (request: Extract<TreeItemRequest, { requestType: 'navigate' }>) => {\n    let isScrollPrevented = false;\n    props.onNavigation?.(request.event, {\n      ...request,\n      preventScroll: () => {\n        isScrollPrevented = true;\n      },\n      isScrollPrevented: () => isScrollPrevented,\n    });\n    switch (request.type) {\n      case treeDataTypes.ArrowDown:\n      case treeDataTypes.ArrowUp:\n      case treeDataTypes.Home:\n      case treeDataTypes.End:\n        // stop the default behavior of the event\n        // which is to scroll the page\n        request.event.preventDefault();\n    }\n  };\n\n  const requestTreeResponse = useEventCallback((request: TreeItemRequest) => {\n    switch (request.requestType) {\n      case 'navigate':\n        return requestNavigation(request);\n      case 'open':\n        return requestOpenChange(request);\n      case 'selection':\n        return requestCheckedChange(request);\n    }\n  });\n\n  return {\n    components: {\n      root: 'div',\n      // TODO: remove once React v18 slot API is modified\n      // This is a problem at the moment due to UnknownSlotProps assumption\n      // that `children` property is `ReactNode`, which in this case is not valid\n      // as PresenceComponentProps['children'] is `ReactElement`\n      collapseMotion: Collapse as React.FC<PresenceMotionSlotProps>,\n    },\n    contextType: 'root',\n    selectionMode,\n    open: true,\n    appearance,\n    size,\n    level: 1,\n    openItems,\n    checkedItems,\n    requestTreeResponse,\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        role: 'tree',\n        'aria-multiselectable': selectionMode === 'multiselect' ? true : undefined,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n    collapseMotion: undefined,\n  };\n}\n\nfunction warnIfNoProperPropsRootTree(props: Pick<TreeProps, 'aria-label' | 'aria-labelledby'>) {\n  if (process.env.NODE_ENV === 'development') {\n    if (!props['aria-label'] && !props['aria-labelledby']) {\n      // eslint-disable-next-line no-console\n      console.warn(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useRootTree]:\n        Tree must have either a \\`aria-label\\` or \\`aria-labelledby\\` property defined\n      `);\n    }\n  }\n}\n"],"names":["useRootTree","props","ref","warnIfNoProperPropsRootTree","appearance","size","selectionMode","openItems","React","useMemo","createOpenItems","checkedItems","createCheckedItems","requestOpenChange","request","onOpenChange","event","createNextOpenItems","dangerouslyGetInternalSet_unstable","requestCheckedChange","onCheckedChange","dangerouslyGetInternalMap_unstable","requestNavigation","isScrollPrevented","onNavigation","preventScroll","type","treeDataTypes","ArrowDown","ArrowUp","Home","End","preventDefault","requestTreeResponse","useEventCallback","requestType","components","root","collapseMotion","Collapse","contextType","open","level","slot","always","getIntrinsicElementProps","role","undefined","elementType","process","env","NODE_ENV","console","warn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAiBgBA;;;eAAAA;;;;gCAjBiD;iEAE1C;8CACE;iCAGO;oCACG;wBACL;0CACM;AAQ7B,SAASA,YACdC,KAAgB,EAChBC,GAA2B;IAE3BC,4BAA4BF;IAE5B,MAAM,EAAEG,aAAa,QAAQ,EAAEC,OAAO,QAAQ,EAAEC,gBAAgB,MAAM,EAAE,GAAGL;IAE3E,MAAMM,YAAYC,OAAMC,OAAO,CAAC,IAAMC,IAAAA,gCAAAA,EAAgBT,MAAMM,SAAS,GAAG;QAACN,MAAMM,SAAS;KAAC;IACzF,MAAMI,eAAeH,OAAMC,OAAO,CAAC,IAAMG,IAAAA,sCAAAA,EAAmBX,MAAMU,YAAY,GAAG;QAACV,MAAMU,YAAY;KAAC;IAErG,MAAME,oBAAoB,CAACC;YACzBb;QAAAA,CAAAA,sBAAAA,MAAMc,YAAY,AAAZA,MAAY,QAAlBd,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBa,QAAQE,KAAK,EAAE;YAClC,GAAGF,OAAO;YACVP,WAAWU,IAAAA,6CAAAA,EAAoBH,SAASP,WAAWW,kCAAkC;QACvF;IACF;IAEA,MAAMC,uBAAuB,CAACL;YAI5Bb;QAHA,IAAIK,kBAAkB,QAAQ;YAC5B;QACF;QACAL,CAAAA,yBAAAA,MAAMmB,eAAe,AAAfA,MAAe,QAArBnB,2BAAAA,KAAAA,IAAAA,KAAAA,IAAAA,uBAAAA,IAAAA,CAAAA,OAAwBa,QAAQE,KAAK,EAAE;YACrC,GAAGF,OAAO;YACVR;YACAK,cAAcA,aAAaU,kCAAkC;QAE/D;IACF;IAEA,MAAMC,oBAAoB,CAACR;YAEzBb;QADA,IAAIsB,oBAAoB;QACxBtB,CAAAA,sBAAAA,MAAMuB,YAAY,AAAZA,MAAY,QAAlBvB,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBa,QAAQE,KAAK,EAAE;YAClC,GAAGF,OAAO;YACVW,eAAe;gBACbF,oBAAoB;YACtB;YACAA,mBAAmB,IAAMA;QAC3B;QACA,OAAQT,QAAQY,IAAI;YAClB,KAAKC,qBAAAA,CAAcC,SAAS;YAC5B,KAAKD,qBAAAA,CAAcE,OAAO;YAC1B,KAAKF,qBAAAA,CAAcG,IAAI;YACvB,KAAKH,qBAAAA,CAAcI,GAAG;gBACpB,yCAAyC;gBACzC,8BAA8B;gBAC9BjB,QAAQE,KAAK,CAACgB,cAAc;QAChC;IACF;IAEA,MAAMC,sBAAsBC,IAAAA,gCAAAA,EAAiB,CAACpB;QAC5C,OAAQA,QAAQqB,WAAW;YACzB,KAAK;gBACH,OAAOb,kBAAkBR;YAC3B,KAAK;gBACH,OAAOD,kBAAkBC;YAC3B,KAAK;gBACH,OAAOK,qBAAqBL;QAChC;IACF;IAEA,OAAO;QACLsB,YAAY;YACVC,MAAM;YACN,mDAAmD;YACnD,qEAAqE;YACrE,2EAA2E;YAC3E,0DAA0D;YAC1DC,gBAAgBC,sCAAAA;QAClB;QACAC,aAAa;QACblC;QACAmC,MAAM;QACNrC;QACAC;QACAqC,OAAO;QACPnC;QACAI;QACAsB;QACAI,MAAMM,oBAAAA,CAAKC,MAAM,CACfC,IAAAA,wCAAAA,EAAyB,OAAO;YAC9B,SAAS;YACT,4EAA4E;YAC5E,4FAA4F;YAC5F3C,KAAKA;YACL4C,MAAM;YACN,wBAAwBxC,kBAAkB,gBAAgB,OAAOyC;YACjE,GAAG9C,KAAK;QACV,IACA;YAAE+C,aAAa;QAAM;QAEvBV,gBAAgBS;IAClB;AACF;AAEA,SAAS5C,4BAA4BF,KAAwD;IAC3F,IAAIgD,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,IAAI,CAAClD,KAAK,CAAC,aAAa,IAAI,CAACA,KAAK,CAAC,kBAAkB,EAAE;YACrD,sCAAsC;YACtCmD,QAAQC,IAAI,CAAsB,CAAC;8EAGnC,CAAC;QACH;IACF;AACF"}
+{"version":3,"sources":["useRootTree.ts"],"sourcesContent":["import { getIntrinsicElementProps, useEventCallback, slot } from '@fluentui/react-utilities';\nimport type { TreeCheckedChangeData, TreeProps, TreeState } from '../Tree';\nimport * as React from 'react';\nimport { Collapse } from '@fluentui/react-motion-components-preview';\nimport { PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport { TreeContextValue, TreeItemRequest } from '../contexts/treeContext';\nimport { createCheckedItems } from '../utils/createCheckedItems';\nimport { treeDataTypes } from '../utils/tokens';\nimport { createNextOpenItems } from './useControllableOpenItems';\nimport { ImmutableSet } from '../utils/ImmutableSet';\nimport { ImmutableMap } from '../utils/ImmutableMap';\n\n/**\n * Create the state required to render the root level tree.\n *\n * @param props - props from this instance of tree\n * @param ref - reference to root HTMLElement of tree\n */\nexport function useRootTree(\n  props: TreeProps,\n  ref: React.Ref<HTMLElement>,\n): Omit<TreeState & TreeContextValue, 'treeType'> {\n  warnIfNoProperPropsRootTree(props);\n\n  const { appearance = 'subtle', size = 'medium', selectionMode = 'none' } = props;\n\n  const openItems = React.useMemo(() => ImmutableSet.from(props.openItems), [props.openItems]);\n  const checkedItems = React.useMemo(() => createCheckedItems(props.checkedItems), [props.checkedItems]);\n\n  const requestOpenChange = (request: Extract<TreeItemRequest, { requestType: 'open' }>) => {\n    props.onOpenChange?.(request.event, {\n      ...request,\n      openItems: ImmutableSet.dangerouslyGetInternalSet(createNextOpenItems(request, openItems)),\n    });\n  };\n\n  const requestCheckedChange = (request: Extract<TreeItemRequest, { requestType: 'selection' }>) => {\n    if (selectionMode === 'none') {\n      return;\n    }\n    props.onCheckedChange?.(request.event, {\n      ...request,\n      selectionMode,\n      checkedItems: ImmutableMap.dangerouslyGetInternalMap(checkedItems),\n      // Casting is required here due to selection | multiselection spreading the union problem\n    } as TreeCheckedChangeData);\n  };\n\n  const requestNavigation = (request: Extract<TreeItemRequest, { requestType: 'navigate' }>) => {\n    let isScrollPrevented = false;\n    props.onNavigation?.(request.event, {\n      ...request,\n      preventScroll: () => {\n        isScrollPrevented = true;\n      },\n      isScrollPrevented: () => isScrollPrevented,\n    });\n    switch (request.type) {\n      case treeDataTypes.ArrowDown:\n      case treeDataTypes.ArrowUp:\n      case treeDataTypes.Home:\n      case treeDataTypes.End:\n        // stop the default behavior of the event\n        // which is to scroll the page\n        request.event.preventDefault();\n    }\n  };\n\n  const requestTreeResponse = useEventCallback((request: TreeItemRequest) => {\n    switch (request.requestType) {\n      case 'navigate':\n        return requestNavigation(request);\n      case 'open':\n        return requestOpenChange(request);\n      case 'selection':\n        return requestCheckedChange(request);\n    }\n  });\n\n  return {\n    components: {\n      root: 'div',\n      // TODO: remove once React v18 slot API is modified\n      // This is a problem at the moment due to UnknownSlotProps assumption\n      // that `children` property is `ReactNode`, which in this case is not valid\n      // as PresenceComponentProps['children'] is `ReactElement`\n      collapseMotion: Collapse as React.FC<PresenceMotionSlotProps>,\n    },\n    contextType: 'root',\n    selectionMode,\n    open: true,\n    appearance,\n    size,\n    level: 1,\n    openItems,\n    checkedItems,\n    requestTreeResponse,\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        role: 'tree',\n        'aria-multiselectable': selectionMode === 'multiselect' ? true : undefined,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n    collapseMotion: undefined,\n  };\n}\n\nfunction warnIfNoProperPropsRootTree(props: Pick<TreeProps, 'aria-label' | 'aria-labelledby'>) {\n  if (process.env.NODE_ENV === 'development') {\n    if (!props['aria-label'] && !props['aria-labelledby']) {\n      // eslint-disable-next-line no-console\n      console.warn(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useRootTree]:\n        Tree must have either a \\`aria-label\\` or \\`aria-labelledby\\` property defined\n      `);\n    }\n  }\n}\n"],"names":["useRootTree","props","ref","warnIfNoProperPropsRootTree","appearance","size","selectionMode","openItems","React","useMemo","ImmutableSet","from","checkedItems","createCheckedItems","requestOpenChange","request","onOpenChange","event","dangerouslyGetInternalSet","createNextOpenItems","requestCheckedChange","onCheckedChange","ImmutableMap","dangerouslyGetInternalMap","requestNavigation","isScrollPrevented","onNavigation","preventScroll","type","treeDataTypes","ArrowDown","ArrowUp","Home","End","preventDefault","requestTreeResponse","useEventCallback","requestType","components","root","collapseMotion","Collapse","contextType","open","level","slot","always","getIntrinsicElementProps","role","undefined","elementType","process","env","NODE_ENV","console","warn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/utils/ImmutableMap.js

@@ -8,44 +8,75 @@ Object.defineProperty(exports, "ImmutableMap", {
         return ImmutableMap;
     }
 });
-const emptyImmutableMap = createImmutableMap();
-/**
- * properly creates an ImmutableMap instance from an iterable
- */ function createImmutableMap(iterable) {
-    const internalMap = new Map(iterable);
-    return dangerouslyCreateImmutableMap(internalMap);
-}
-/**
- * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,
- * @param internalMap - a set that is used internally to store values.
- */ function dangerouslyCreateImmutableMap(internalMap) {
-    return {
-        size: internalMap.size,
-        set: (key, value)=>{
-            const nextSet = new Map(internalMap);
-            nextSet.set(key, value);
-            return dangerouslyCreateImmutableMap(nextSet);
-        },
-        get: (key)=>internalMap.get(key),
-        clear: ()=>emptyImmutableMap,
-        delete (value) {
-            const nextSet = new Map(internalMap);
-            nextSet.delete(value);
-            return dangerouslyCreateImmutableMap(nextSet);
-        },
-        has: (value)=>internalMap.has(value),
-        [Symbol.iterator]: ()=>internalMap[Symbol.iterator](),
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        dangerouslyGetInternalMap_unstable: ()=>internalMap
-    };
-}
-function isImmutableMap(value) {
-    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;
+const _define_property = require("@swc/helpers/_/_define_property");
+const internalMapSymbol = Symbol('#internalMap');
+let _internalMapSymbol = internalMapSymbol, _Symbol_hasInstance = Symbol.hasInstance, _Symbol_iterator = Symbol.iterator;
+class ImmutableMap {
+    static dangerouslyGetInternalMap(immutableMap) {
+        return immutableMap[internalMapSymbol];
+    }
+    static copy(immutableMap) {
+        return this.from(immutableMap[internalMapSymbol]);
+    }
+    static from(iterable, mapFn) {
+        if (iterable === undefined) {
+            return this.empty;
+        }
+        if (!mapFn) {
+            if (iterable instanceof this) {
+                return iterable;
+            }
+            // casting here is ok, as the function overload ensures that the iterable is
+            // Iterable<[unknown, unknown]>
+            // if mapFn is not provided
+            const iterableAsTuple = iterable;
+            return new this(new Map(iterableAsTuple));
+        }
+        const map = new Map();
+        for (const value of iterable){
+            map.set(...mapFn(value));
+        }
+        return new this(map);
+    }
+    static [_Symbol_hasInstance](instance) {
+        return Boolean(typeof instance === 'object' && instance && internalMapSymbol in instance);
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            return this;
+        }
+        const copy = ImmutableMap.copy(this);
+        copy[internalMapSymbol].delete(key);
+        return copy;
+    }
+    get(key) {
+        return this[internalMapSymbol].get(key);
+    }
+    has(key) {
+        return this[internalMapSymbol].has(key);
+    }
+    set(key, value) {
+        if (this.get(key) === value) {
+            return this;
+        }
+        const copy = ImmutableMap.copy(this);
+        copy[internalMapSymbol].set(key, value);
+        return copy;
+    }
+    [_Symbol_iterator]() {
+        return this[internalMapSymbol].entries();
+    }
+    /**
+   * Do not use this constructor directly, use {@link ImmutableMap.from} instead.
+   * {@link ImmutableMap.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),
+   * avoid unnecessary copies, supports iterables and ensures that the internal map is never exposed.
+   *
+   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable map, as it is not guaranteed that the internal map is not exposed._ ⚠️⚠️
+   */ constructor(internalMap){
+        (0, _define_property._)(this, "size", void 0);
+        (0, _define_property._)(this, _internalMapSymbol, void 0);
+        this[internalMapSymbol] = internalMap;
+        this.size = this[internalMapSymbol].size;
+    }
 }
-const ImmutableMap = {
-    empty: emptyImmutableMap,
-    create: createImmutableMap,
-    isImmutableMap,
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap
-};
+(0, _define_property._)(ImmutableMap, "empty", new ImmutableMap(new Map()));

package/lib-commonjs/utils/ImmutableMap.js.map

@@ -1 +1 @@
-{"version":3,"sources":["ImmutableMap.ts"],"sourcesContent":["export interface ImmutableMap<Key, Value> {\n  clear(): ImmutableMap<Key, Value>;\n  delete(key: Key): ImmutableMap<Key, Value>;\n  /**\n   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.\n   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.\n   */\n  get(key: Key): Value | undefined;\n  /**\n   * @returns boolean indicating whether an element with the specified key exists or not.\n   */\n  has(key: Key): boolean;\n  /**\n   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.\n   */\n  set(key: Key, value: Value): ImmutableMap<Key, Value>;\n  /**\n   * @returns the number of elements in the Map.\n   */\n  readonly size: number;\n  /** Iterates over entries in the Map. */\n  [Symbol.iterator](): IterableIterator<[Key, Value]>;\n  /**\n   * @internal\n   * Exposes the internal map used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalMap_unstable(): Map<Key, Value>;\n}\n\nconst emptyImmutableMap = createImmutableMap<never, never>();\n\n/**\n * properly creates an ImmutableMap instance from an iterable\n */\nfunction createImmutableMap<Key, Value>(iterable?: Iterable<[Key, Value]>): ImmutableMap<Key, Value> {\n  const internalMap = new Map(iterable);\n  return dangerouslyCreateImmutableMap(internalMap);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,\n * @param internalMap - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableMap<Key, Value>(internalMap: Map<Key, Value>): ImmutableMap<Key, Value> {\n  return {\n    size: internalMap.size,\n    set: (key, value) => {\n      const nextSet = new Map(internalMap);\n      nextSet.set(key, value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    get: key => internalMap.get(key),\n    clear: () => emptyImmutableMap,\n    delete(value) {\n      const nextSet = new Map(internalMap);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    has: value => internalMap.has(value),\n    [Symbol.iterator]: () => internalMap[Symbol.iterator](),\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalMap_unstable: () => internalMap,\n  };\n}\n\nfunction isImmutableMap<Key, Value>(value: unknown): value is ImmutableMap<Key, Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;\n}\n\nexport const ImmutableMap = {\n  empty: emptyImmutableMap,\n  create: createImmutableMap,\n  isImmutableMap,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableMap,\n};\n"],"names":["ImmutableMap","emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAsEaA;;;eAAAA;;;AAvCb,MAAMC,oBAAoBC;AAE1B;;CAEC,GACD,SAASA,mBAA+BC,QAAiC;IACvE,MAAMC,cAAc,IAAIC,IAAIF;IAC5B,OAAOG,8BAA8BF;AACvC;AACA;;;CAGC,GACD,SAASE,8BAA0CF,WAA4B;IAC7E,OAAO;QACLG,MAAMH,YAAYG,IAAI;QACtBC,KAAK,CAACC,KAAKC;YACT,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQH,GAAG,CAACC,KAAKC;YACjB,OAAOJ,8BAA8BK;QACvC;QACAC,KAAKH,CAAAA,MAAOL,YAAYQ,GAAG,CAACH;QAC5BI,OAAO,IAAMZ;QACba,QAAOJ,KAAK;YACV,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAKL,CAAAA,QAASN,YAAYW,GAAG,CAACL;QAC9B,CAACM,OAAOC,QAAQ,CAAC,EAAE,IAAMb,WAAW,CAACY,OAAOC,QAAQ,CAAC;QACrD,gEAAgE;QAChEC,oCAAoC,IAAMd;IAC5C;AACF;AAEA,SAASe,eAA2BT,KAAc;IAChD,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAChG;AAEO,MAAMV,eAAe;IAC1BoB,OAAOnB;IACPoB,QAAQnB;IACRiB;IACA,gEAAgE;IAChEG,4BAA4BhB;AAC9B"}
+{"version":3,"sources":["ImmutableMap.ts"],"sourcesContent":["const internalMapSymbol = Symbol('#internalMap');\n\nexport class ImmutableMap<Key, Value> implements Iterable<[Key, Value]> {\n  public static empty: ImmutableMap<never, never> = new ImmutableMap(new Map<never, never>());\n  public readonly size: number;\n\n  private [internalMapSymbol]: Map<Key, Value>;\n\n  public static dangerouslyGetInternalMap<Key, Value>(immutableMap: ImmutableMap<Key, Value>): Map<Key, Value> {\n    return immutableMap[internalMapSymbol];\n  }\n\n  public static copy<Key, Value>(immutableMap: ImmutableMap<Key, Value>): ImmutableMap<Key, Value> {\n    return this.from(immutableMap[internalMapSymbol]);\n  }\n\n  /**\n   * Creates a new {@link ImmutableMap} from an iterable.\n   * If the iterable is undefined, {@link ImmutableMap.empty} will be returned.\n   * If the iterable is already an {@link ImmutableMap}, it will be returned as is no copy will be made.\n   */\n  public static from<T extends [unknown, unknown]>(iterable?: Iterable<T>): ImmutableMap<T[0], T[1]>;\n  /**\n   * Creates a new {@link ImmutableMap} from an iterable with an auxiliary map function to modify the iterable.\n   * If the iterable is undefined, {@link ImmutableMap.empty} will be returned.\n   * If the iterable is already an {@link ImmutableMap}, it will be returned as is no copy will be made.\n   * The map function will be called for each element in the iterable.\n   */\n  public static from<T, U extends [unknown, unknown]>(\n    iterable: Iterable<T> | undefined,\n    mapFn: (value: T) => U,\n  ): ImmutableMap<U[0], U[1]>;\n  public static from(\n    iterable?: Iterable<unknown>,\n    mapFn?: (value: unknown) => [unknown, unknown],\n  ): ImmutableMap<unknown, unknown> {\n    if (iterable === undefined) {\n      return this.empty;\n    }\n    if (!mapFn) {\n      if (iterable instanceof this) {\n        return iterable;\n      }\n      // casting here is ok, as the function overload ensures that the iterable is\n      // Iterable<[unknown, unknown]>\n      // if mapFn is not provided\n      const iterableAsTuple = iterable as Iterable<[unknown, unknown]>;\n      return new this(new Map(iterableAsTuple));\n    }\n    const map = new Map<unknown, unknown>();\n    for (const value of iterable) {\n      map.set(...mapFn(value));\n    }\n    return new this(map);\n  }\n\n  public static [Symbol.hasInstance](instance: unknown): boolean {\n    return Boolean(typeof instance === 'object' && instance && internalMapSymbol in instance);\n  }\n\n  /**\n   * Do not use this constructor directly, use {@link ImmutableMap.from} instead.\n   * {@link ImmutableMap.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),\n   * avoid unnecessary copies, supports iterables and ensures that the internal map is never exposed.\n   *\n   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable map, as it is not guaranteed that the internal map is not exposed._ ⚠️⚠️\n   */\n  constructor(internalMap: Map<Key, Value>) {\n    this[internalMapSymbol] = internalMap;\n    this.size = this[internalMapSymbol].size;\n  }\n\n  public delete(key: Key): ImmutableMap<Key, Value> {\n    if (!this.has(key)) {\n      return this;\n    }\n    const copy = ImmutableMap.copy(this);\n    copy[internalMapSymbol].delete(key);\n    return copy;\n  }\n  public get(key: Key): Value | undefined {\n    return this[internalMapSymbol].get(key);\n  }\n  public has(key: Key): boolean {\n    return this[internalMapSymbol].has(key);\n  }\n  public set(key: Key, value: Value): ImmutableMap<Key, Value> {\n    if (this.get(key) === value) {\n      return this;\n    }\n    const copy = ImmutableMap.copy(this);\n    copy[internalMapSymbol].set(key, value);\n    return copy;\n  }\n  public [Symbol.iterator](): Iterator<[Key, Value]> {\n    return this[internalMapSymbol].entries();\n  }\n}\n"],"names":["ImmutableMap","internalMapSymbol","Symbol","hasInstance","iterator","dangerouslyGetInternalMap","immutableMap","copy","from","iterable","mapFn","undefined","empty","iterableAsTuple","Map","map","value","set","instance","Boolean","delete","key","has","get","entries","constructor","internalMap","_define_property","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;;AAFb,MAAMC,oBAAoBC,OAAO;IAMtBD,qBAAAA,mBAkDMC,sBAAAA,OAAOC,WAAW,EAsCzBD,mBAAAA,OAAOE,QAAQ;AA5FlB,MAAMJ;IAMX,OAAcK,0BAAsCC,YAAsC,EAAmB;QAC3G,OAAOA,YAAY,CAACL,kBAAkB;IACxC;IAEA,OAAcM,KAAiBD,YAAsC,EAA4B;QAC/F,OAAO,IAAI,CAACE,IAAI,CAACF,YAAY,CAACL,kBAAkB;IAClD;IAkBA,OAAcO,KACZC,QAA4B,EAC5BC,KAA8C,EACd;QAChC,IAAID,aAAaE,WAAW;YAC1B,OAAO,IAAI,CAACC,KAAK;QACnB;QACA,IAAI,CAACF,OAAO;YACV,IAAID,oBAAoB,IAAI,EAAE;gBAC5B,OAAOA;YACT;YACA,4EAA4E;YAC5E,+BAA+B;YAC/B,2BAA2B;YAC3B,MAAMI,kBAAkBJ;YACxB,OAAO,IAAI,IAAI,CAAC,IAAIK,IAAID;QAC1B;QACA,MAAME,MAAM,IAAID;QAChB,KAAK,MAAME,SAASP,SAAU;YAC5BM,IAAIE,GAAG,IAAIP,MAAMM;QACnB;QACA,OAAO,IAAI,IAAI,CAACD;IAClB;IAEA,OAAc,CAACb,oBAAmB,CAACgB,QAAiB,EAAW;QAC7D,OAAOC,QAAQ,OAAOD,aAAa,YAAYA,YAAYjB,qBAAqBiB;IAClF;IAcOE,OAAOC,GAAQ,EAA4B;QAChD,IAAI,CAAC,IAAI,CAACC,GAAG,CAACD,MAAM;YAClB,OAAO,IAAI;QACb;QACA,MAAMd,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACmB,MAAM,CAACC;QAC/B,OAAOd;IACT;IACOgB,IAAIF,GAAQ,EAAqB;QACtC,OAAO,IAAI,CAACpB,kBAAkB,CAACsB,GAAG,CAACF;IACrC;IACOC,IAAID,GAAQ,EAAW;QAC5B,OAAO,IAAI,CAACpB,kBAAkB,CAACqB,GAAG,CAACD;IACrC;IACOJ,IAAII,GAAQ,EAAEL,KAAY,EAA4B;QAC3D,IAAI,IAAI,CAACO,GAAG,CAACF,SAASL,OAAO;YAC3B,OAAO,IAAI;QACb;QACA,MAAMT,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACgB,GAAG,CAACI,KAAKL;QACjC,OAAOT;IACT;IACO,CAACL,iBAAgB,GAA2B;QACjD,OAAO,IAAI,CAACD,kBAAkB,CAACuB,OAAO;IACxC;IApCA;;;;;;GAMC,GACDC,YAAYC,WAA4B,CAAE;QA/D1CC,IAAAA,kBAAA,EAAA,IAAA,EAAgBC,QAAhB,KAAA;QAEAD,IAAAA,kBAAA,EAAA,IAAA,EAAS1B,oBAAT,KAAA;QA8DE,IAAI,CAACA,kBAAkB,GAAGyB;QAC1B,IAAI,CAACE,IAAI,GAAG,IAAI,CAAC3B,kBAAkB,CAAC2B,IAAI;IAC1C;AA2BF;AA9FED,IAAAA,kBAAA,EADW3B,cACGY,SAAoC,IAAIZ,aAAa,IAAIc"}

package/lib-commonjs/utils/ImmutableSet.js

@@ -8,49 +8,65 @@ Object.defineProperty(exports, "ImmutableSet", {
         return ImmutableSet;
     }
 });
-const emptyImmutableSet = createImmutableSet();
-/**
- * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,
- * @param internalSet - a set that is used internally to store values.
- */ function dangerouslyCreateImmutableSet(internalSet) {
-    return {
-        size: internalSet.size,
-        add (value) {
-            const nextSet = new Set(internalSet);
-            nextSet.add(value);
-            return dangerouslyCreateImmutableSet(nextSet);
-        },
-        clear () {
-            return emptyImmutableSet;
-        },
-        delete (value) {
-            const nextSet = new Set(internalSet);
-            nextSet.delete(value);
-            return dangerouslyCreateImmutableSet(nextSet);
-        },
-        has (value) {
-            return internalSet.has(value);
-        },
-        [Symbol.iterator] () {
-            return internalSet[Symbol.iterator]();
-        },
-        // eslint-disable-next-line @typescript-eslint/naming-convention
-        dangerouslyGetInternalSet_unstable: ()=>internalSet
-    };
-}
-function isImmutableSet(value) {
-    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;
-}
-/**
- * properly creates an ImmutableSet instance from an iterable
- */ function createImmutableSet(iterable) {
-    const internalSet = new Set(iterable);
-    return dangerouslyCreateImmutableSet(internalSet);
+const _define_property = require("@swc/helpers/_/_define_property");
+const internalSetSymbol = Symbol('#internalSet');
+let _internalSetSymbol = internalSetSymbol, _Symbol_hasInstance = Symbol.hasInstance, _Symbol_iterator = Symbol.iterator;
+class ImmutableSet {
+    static dangerouslyGetInternalSet(set) {
+        return set[internalSetSymbol];
+    }
+    static copy(immutableSet) {
+        return new ImmutableSet(new Set(immutableSet[internalSetSymbol]));
+    }
+    /**
+   * Creates a new {@link ImmutableSet} from an iterable.
+   * If the iterable is undefined, {@link ImmutableSet.empty} will be returned.
+   * If the iterable is already an {@link ImmutableSet}, it will be returned as is no copy will be made.
+   */ static from(iterable) {
+        if (iterable === undefined) {
+            return this.empty;
+        }
+        if (iterable instanceof this) {
+            return iterable;
+        }
+        return new this(new Set(iterable));
+    }
+    static [_Symbol_hasInstance](instance) {
+        return Boolean(typeof instance === 'object' && instance && internalSetSymbol in instance);
+    }
+    add(value) {
+        if (this.has(value)) {
+            return this;
+        }
+        const copy = ImmutableSet.copy(this);
+        copy[internalSetSymbol].add(value);
+        return copy;
+    }
+    delete(value) {
+        if (!this.has(value)) {
+            return this;
+        }
+        const copy = ImmutableSet.copy(this);
+        copy[internalSetSymbol].delete(value);
+        return copy;
+    }
+    has(value) {
+        return this[internalSetSymbol].has(value);
+    }
+    [_Symbol_iterator]() {
+        return this[internalSetSymbol].values();
+    }
+    /**
+   * Do not use this constructor directly, use {@link ImmutableSet.from} instead.
+   * {@link ImmutableSet.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),
+   * avoid unnecessary copies, supports iterables and ensures that the internal set is never exposed.
+   *
+   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable set, as it is not guaranteed that the internal set is not exposed._ ⚠️⚠️
+   */ constructor(internalSet){
+        (0, _define_property._)(this, "size", void 0);
+        (0, _define_property._)(this, _internalSetSymbol, void 0);
+        this[internalSetSymbol] = internalSet;
+        this.size = this[internalSetSymbol].size;
+    }
 }
-const ImmutableSet = {
-    empty: emptyImmutableSet,
-    create: createImmutableSet,
-    isImmutableSet,
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet
-};
+(0, _define_property._)(ImmutableSet, "empty", new ImmutableSet(new Set()));

package/lib-commonjs/utils/ImmutableSet.js.map

@@ -1 +1 @@
-{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["export interface ImmutableSet<Value> {\n  /**\n   * The number of (unique) elements in a ImmutableSet.\n   */\n  readonly size: number;\n  /**\n   * Creates a new ImmutableSet containing all previous element plus the one provided as argument\n   * @param value - new value to be included in the new ImmutableSet instance\n   */\n  add(value: Value): ImmutableSet<Value>;\n  /**\n   * Returns a reference to ImmutableSet.emptySet\n   */\n  clear(): ImmutableSet<Value>;\n  /**\n   * Creates a new ImmutableSet with the original items and removes a specified value from the new ImmutableSet.\n   */\n  delete(value: Value): ImmutableSet<Value>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the ImmutableSet or not.\n   */\n  has(value: Value): boolean;\n  /** Iterates over values in the ImmutableSet. */\n  [Symbol.iterator](): IterableIterator<Value>;\n  /**\n   * @internal\n   * Exposes the internal set used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalSet_unstable(): Set<Value>;\n}\n\nconst emptyImmutableSet = createImmutableSet<never>();\n\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableSet<Value>(internalSet: Set<Value>): ImmutableSet<Value> {\n  return {\n    size: internalSet.size,\n    add(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.add(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    clear() {\n      return emptyImmutableSet;\n    },\n    delete(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    has(value) {\n      return internalSet.has(value);\n    },\n    [Symbol.iterator]() {\n      return internalSet[Symbol.iterator]();\n    },\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalSet_unstable: () => internalSet,\n  };\n}\n\nfunction isImmutableSet<Value>(value: unknown): value is ImmutableSet<Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;\n}\n\n/**\n * properly creates an ImmutableSet instance from an iterable\n */\nfunction createImmutableSet<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n  const internalSet = new Set(iterable);\n  return dangerouslyCreateImmutableSet(internalSet);\n}\n\nexport const ImmutableSet = {\n  empty: emptyImmutableSet,\n  create: createImmutableSet,\n  isImmutableSet,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableSet,\n};\n"],"names":["ImmutableSet","emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA8EaA;;;eAAAA;;;AA7Cb,MAAMC,oBAAoBC;AAE1B;;;CAGC,GACD,SAASC,8BAAqCC,WAAuB;IACnE,OAAO;QACLC,MAAMD,YAAYC,IAAI;QACtBC,KAAIC,KAAK;YACP,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACvC;QACAE;YACE,OAAOT;QACT;QACAU,QAAOJ,KAAK;YACV,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAIL,KAAK;YACP,OAAOH,YAAYQ,GAAG,CAACL;QACzB;QACA,CAACM,OAAOC,QAAQ,CAAC;YACf,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACrC;QACA,gEAAgE;QAChEC,oCAAoC,IAAMX;IAC5C;AACF;AAEA,SAASY,eAAsBT,KAAc;IAC3C,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAChG;AAEA;;CAEC,GACD,SAASL,mBAA0Be,QAA0B;IAC3D,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACvC;AAEO,MAAMJ,eAAe;IAC1BkB,OAAOjB;IACPkB,QAAQjB;IACRc;IACA,gEAAgE;IAChEI,4BAA4BjB;AAC9B"}
+{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["const internalSetSymbol = Symbol('#internalSet');\n\n/**\n * @public\n *\n * Small immutable wrapper around the native Set implementation.\n * Every operation that would modify the set returns a new copy instance.\n */\nexport class ImmutableSet<T> implements Iterable<T> {\n  public static empty: ImmutableSet<never> = new ImmutableSet(new Set());\n  public readonly size: number;\n\n  private [internalSetSymbol]: Set<T>;\n\n  public static dangerouslyGetInternalSet<Value>(set: ImmutableSet<Value>): Set<Value> {\n    return set[internalSetSymbol];\n  }\n\n  public static copy<T>(immutableSet: ImmutableSet<T>): ImmutableSet<T> {\n    return new ImmutableSet(new Set(immutableSet[internalSetSymbol]));\n  }\n\n  /**\n   * Creates a new {@link ImmutableSet} from an iterable.\n   * If the iterable is undefined, {@link ImmutableSet.empty} will be returned.\n   * If the iterable is already an {@link ImmutableSet}, it will be returned as is no copy will be made.\n   */\n  public static from<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n    if (iterable === undefined) {\n      return this.empty;\n    }\n    if (iterable instanceof this) {\n      return iterable;\n    }\n    return new this(new Set(iterable));\n  }\n\n  public static [Symbol.hasInstance](instance: unknown): boolean {\n    return Boolean(typeof instance === 'object' && instance && internalSetSymbol in instance);\n  }\n\n  /**\n   * Do not use this constructor directly, use {@link ImmutableSet.from} instead.\n   * {@link ImmutableSet.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),\n   * avoid unnecessary copies, supports iterables and ensures that the internal set is never exposed.\n   *\n   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable set, as it is not guaranteed that the internal set is not exposed._ ⚠️⚠️\n   */\n  constructor(internalSet: Set<T>) {\n    this[internalSetSymbol] = internalSet;\n    this.size = this[internalSetSymbol].size;\n  }\n\n  public add(value: T): ImmutableSet<T> {\n    if (this.has(value)) {\n      return this;\n    }\n    const copy = ImmutableSet.copy(this);\n    copy[internalSetSymbol].add(value);\n    return copy;\n  }\n\n  public delete(value: T): ImmutableSet<T> {\n    if (!this.has(value)) {\n      return this;\n    }\n    const copy = ImmutableSet.copy(this);\n    copy[internalSetSymbol].delete(value);\n    return copy;\n  }\n\n  public has(value: T): boolean {\n    return this[internalSetSymbol].has(value);\n  }\n\n  public [Symbol.iterator](): Iterator<T> {\n    return this[internalSetSymbol].values();\n  }\n}\n"],"names":["ImmutableSet","internalSetSymbol","Symbol","hasInstance","iterator","dangerouslyGetInternalSet","set","copy","immutableSet","Set","from","iterable","undefined","empty","instance","Boolean","add","value","has","delete","values","constructor","internalSet","_define_property","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;;AARb,MAAMC,oBAAoBC,OAAO;IAYtBD,qBAAAA,mBAyBMC,sBAAAA,OAAOC,WAAW,EAsCzBD,mBAAAA,OAAOE,QAAQ;AAnElB,MAAMJ;IAMX,OAAcK,0BAAiCC,GAAwB,EAAc;QACnF,OAAOA,GAAG,CAACL,kBAAkB;IAC/B;IAEA,OAAcM,KAAQC,YAA6B,EAAmB;QACpE,OAAO,IAAIR,aAAa,IAAIS,IAAID,YAAY,CAACP,kBAAkB;IACjE;IAEA;;;;GAIC,GACD,OAAcS,KAAYC,QAA0B,EAAuB;QACzE,IAAIA,aAAaC,WAAW;YAC1B,OAAO,IAAI,CAACC,KAAK;QACnB;QACA,IAAIF,oBAAoB,IAAI,EAAE;YAC5B,OAAOA;QACT;QACA,OAAO,IAAI,IAAI,CAAC,IAAIF,IAAIE;IAC1B;IAEA,OAAc,CAACT,oBAAmB,CAACY,QAAiB,EAAW;QAC7D,OAAOC,QAAQ,OAAOD,aAAa,YAAYA,YAAYb,qBAAqBa;IAClF;IAcOE,IAAIC,KAAQ,EAAmB;QACpC,IAAI,IAAI,CAACC,GAAG,CAACD,QAAQ;YACnB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACe,GAAG,CAACC;QAC5B,OAAOV;IACT;IAEOY,OAAOF,KAAQ,EAAmB;QACvC,IAAI,CAAC,IAAI,CAACC,GAAG,CAACD,QAAQ;YACpB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACkB,MAAM,CAACF;QAC/B,OAAOV;IACT;IAEOW,IAAID,KAAQ,EAAW;QAC5B,OAAO,IAAI,CAAChB,kBAAkB,CAACiB,GAAG,CAACD;IACrC;IAEO,CAACf,iBAAgB,GAAgB;QACtC,OAAO,IAAI,CAACD,kBAAkB,CAACmB,MAAM;IACvC;IApCA;;;;;;GAMC,GACDC,YAAYC,WAAmB,CAAE;QAtCjCC,IAAAA,kBAAA,EAAA,IAAA,EAAgBC,QAAhB,KAAA;QAEAD,IAAAA,kBAAA,EAAA,IAAA,EAAStB,oBAAT,KAAA;QAqCE,IAAI,CAACA,kBAAkB,GAAGqB;QAC1B,IAAI,CAACE,IAAI,GAAG,IAAI,CAACvB,kBAAkB,CAACuB,IAAI;IAC1C;AA2BF;AArEED,IAAAA,kBAAA,EADWvB,cACGa,SAA6B,IAAIb,aAAa,IAAIS"}

package/lib-commonjs/utils/createCheckedItems.js

@@ -9,20 +9,8 @@ Object.defineProperty(exports, "createCheckedItems", {
     }
 });
 const _ImmutableMap = require("./ImmutableMap");
-function createCheckedItems(iterable) {
-    if (iterable === undefined) {
-        return _ImmutableMap.ImmutableMap.empty;
-    }
-    if (_ImmutableMap.ImmutableMap.isImmutableMap(iterable)) {
-        return iterable;
-    }
-    const internalMap = new Map();
-    for (const item of iterable){
-        if (Array.isArray(item)) {
-            internalMap.set(item[0], item[1]);
-        } else {
-            internalMap.set(item, true);
-        }
-    }
-    return _ImmutableMap.ImmutableMap.dangerouslyCreate_unstable(internalMap);
-}
+const tuplifyCheckedItem = (value)=>Array.isArray(value) ? value : [
+        value,
+        true
+    ];
+const createCheckedItems = (iterable)=>_ImmutableMap.ImmutableMap.from(iterable, tuplifyCheckedItem);

package/lib-commonjs/utils/createCheckedItems.js.map

@@ -1 +1 @@
-{"version":3,"sources":["createCheckedItems.ts"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nimport type { TreeSelectionValue } from '../Tree';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createCheckedItems(iterable?: Iterable<TreeItemValue | [TreeItemValue, TreeSelectionValue]>) {\n  if (iterable === undefined) {\n    return ImmutableMap.empty;\n  }\n  if (ImmutableMap.isImmutableMap<TreeItemValue, TreeSelectionValue>(iterable)) {\n    return iterable;\n  }\n  const internalMap = new Map<TreeItemValue, 'mixed' | boolean>();\n  for (const item of iterable) {\n    if (Array.isArray(item)) {\n      internalMap.set(item[0], item[1]);\n    } else {\n      internalMap.set(item, true);\n    }\n  }\n  return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["createCheckedItems","iterable","undefined","ImmutableMap","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;8BAJa;AAItB,SAASA,mBAAmBC,QAAwE;IACzG,IAAIA,aAAaC,WAAW;QAC1B,OAAOC,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAID,0BAAAA,CAAaE,cAAc,CAAoCJ,WAAW;QAC5E,OAAOA;IACT;IACA,MAAMK,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQP,SAAU;QAC3B,IAAIQ,MAAMC,OAAO,CAACF,OAAO;YACvBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QAClC,OAAO;YACLF,YAAYK,GAAG,CAACH,MAAM;QACxB;IACF;IACA,OAAOL,0BAAAA,CAAaS,0BAA0B,CAACN;AACjD"}
+{"version":3,"sources":["createCheckedItems.ts"],"sourcesContent":["import type { TreeSelectionValue } from '../Tree';\nimport type { TreeItemValue } from '../TreeItem';\nimport { ImmutableMap } from './ImmutableMap';\n\nconst tuplifyCheckedItem = (\n  value: TreeItemValue | [TreeItemValue, TreeSelectionValue],\n): [TreeItemValue, TreeSelectionValue] => (Array.isArray(value) ? value : [value, true]);\n\nexport const createCheckedItems = (\n  iterable?: Iterable<TreeItemValue | [TreeItemValue, TreeSelectionValue]>,\n): ImmutableMap<TreeItemValue, TreeSelectionValue> => ImmutableMap.from(iterable, tuplifyCheckedItem);\n"],"names":["createCheckedItems","tuplifyCheckedItem","value","Array","isArray","iterable","ImmutableMap","from"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;8BANgB;AAE7B,MAAMC,qBAAqB,CACzBC,QACyCC,MAAMC,OAAO,CAACF,SAASA,QAAQ;QAACA;QAAO;KAAK;AAEhF,MAAMF,qBAAqB,CAChCK,WACoDC,0BAAAA,CAAaC,IAAI,CAACF,UAAUJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-tree",
-  "version": "9.7.7",
+  "version": "9.7.8",
   "description": "Tree component for Fluent UI React",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",

package/lib/utils/createOpenItems.js

@@ -1,10 +0,0 @@
-import { ImmutableSet } from './ImmutableSet';
-export function createOpenItems(iterable) {
-    if (iterable === undefined) {
-        return ImmutableSet.empty;
-    }
-    if (ImmutableSet.isImmutableSet(iterable)) {
-        return iterable;
-    }
-    return ImmutableSet.create(iterable);
-}

package/lib/utils/createOpenItems.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["createOpenItems.ts"],"sourcesContent":["import { ImmutableSet } from './ImmutableSet';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createOpenItems(iterable?: Iterable<TreeItemValue>) {\n  if (iterable === undefined) {\n    return ImmutableSet.empty;\n  }\n  if (ImmutableSet.isImmutableSet<TreeItemValue>(iterable)) {\n    return iterable;\n  }\n  return ImmutableSet.create(iterable);\n}\n"],"names":["ImmutableSet","createOpenItems","iterable","undefined","empty","isImmutableSet","create"],"rangeMappings":";;;;;;;;;","mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAG9C,OAAO,SAASC,gBAAgBC,QAAkC;IAChE,IAAIA,aAAaC,WAAW;QAC1B,OAAOH,aAAaI,KAAK;IAC3B;IACA,IAAIJ,aAAaK,cAAc,CAAgBH,WAAW;QACxD,OAAOA;IACT;IACA,OAAOF,aAAaM,MAAM,CAACJ;AAC7B"}