@fluentui/react-tree 9.7.1 → 9.7.3

package/lib/utils/nextTypeAheadElement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["nextTypeAheadElement.ts"],"sourcesContent":["import { HTMLElementWalker } from './createHTMLElementWalker';\n\nexport function nextTypeAheadElement(treeWalker: HTMLElementWalker, key: string) {\n  const keyToLowerCase = key.toLowerCase();\n  const typeAheadFilter = (element: HTMLElement) => {\n    return element.textContent?.trim().charAt(0).toLowerCase() === keyToLowerCase\n      ? NodeFilter.FILTER_ACCEPT\n      : NodeFilter.FILTER_SKIP;\n  };\n  let nextElement = treeWalker.nextElement(typeAheadFilter);\n  if (!nextElement) {\n    treeWalker.currentElement = treeWalker.root;\n    nextElement = treeWalker.nextElement(typeAheadFilter);\n  }\n  return nextElement;\n}\n"],"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"mappings":"AAEA,OAAO,SAASA,qBAAqBC,UAA6B,EAAEC,GAAW;IAC7E,MAAMC,iBAAiBD,IAAIE,WAAW;IACtC,MAAMC,kBAAkB,CAACC;YAChBA;QAAP,OAAOA,EAAAA,uBAAAA,QAAQC,WAAW,cAAnBD,2CAAAA,qBAAqBE,IAAI,GAAGC,MAAM,CAAC,GAAGL,WAAW,QAAOD,iBAC3DO,WAAWC,aAAa,GACxBD,WAAWE,WAAW;IAC5B;IACA,IAAIC,cAAcZ,WAAWY,WAAW,CAACR;IACzC,IAAI,CAACQ,aAAa;QAChBZ,WAAWa,cAAc,GAAGb,WAAWc,IAAI;QAC3CF,cAAcZ,WAAWY,WAAW,CAACR;IACvC;IACA,OAAOQ;AACT"}
+{"version":3,"sources":["nextTypeAheadElement.ts"],"sourcesContent":["import { HTMLElementWalker } from './createHTMLElementWalker';\n\nexport function nextTypeAheadElement(treeWalker: HTMLElementWalker, key: string) {\n  const keyToLowerCase = key.toLowerCase();\n  const typeAheadFilter = (element: HTMLElement) => {\n    return element.textContent?.trim().charAt(0).toLowerCase() === keyToLowerCase\n      ? NodeFilter.FILTER_ACCEPT\n      : NodeFilter.FILTER_SKIP;\n  };\n  let nextElement = treeWalker.nextElement(typeAheadFilter);\n  if (!nextElement) {\n    treeWalker.currentElement = treeWalker.root;\n    nextElement = treeWalker.nextElement(typeAheadFilter);\n  }\n  return nextElement;\n}\n"],"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"rangeMappings":";;;;;;;;;;;;","mappings":"AAEA,OAAO,SAASA,qBAAqBC,UAA6B,EAAEC,GAAW;IAC7E,MAAMC,iBAAiBD,IAAIE,WAAW;IACtC,MAAMC,kBAAkB,CAACC;YAChBA;QAAP,OAAOA,EAAAA,uBAAAA,QAAQC,WAAW,cAAnBD,2CAAAA,qBAAqBE,IAAI,GAAGC,MAAM,CAAC,GAAGL,WAAW,QAAOD,iBAC3DO,WAAWC,aAAa,GACxBD,WAAWE,WAAW;IAC5B;IACA,IAAIC,cAAcZ,WAAWY,WAAW,CAACR;IACzC,IAAI,CAACQ,aAAa;QAChBZ,WAAWa,cAAc,GAAGb,WAAWc,IAAI;QAC3CF,cAAcZ,WAAWY,WAAW,CAACR;IACvC;IACA,OAAOQ;AACT"}

package/lib/utils/normalizeOpenItems.js.map

@@ -1 +1 @@
-{"version":3,"sources":["normalizeOpenItems.ts"],"sourcesContent":["export function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: false;\n  },\n): string[];\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined: true;\n  },\n): string[] | undefined;\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: boolean;\n  },\n): string[] | undefined {\n  if (!openSubtrees) {\n    return options?.keepUndefined ? undefined : [];\n  }\n  return Array.isArray(openSubtrees) ? openSubtrees : [openSubtrees];\n}\n"],"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"mappings":"AAcA,OAAO,SAASA,mBACdC,YAAgC,EAChCC,OAEC;IAED,IAAI,CAACD,cAAc;QACjB,OAAOC,CAAAA,oBAAAA,8BAAAA,QAASC,aAAa,IAAGC,YAAY,EAAE;IAChD;IACA,OAAOC,MAAMC,OAAO,CAACL,gBAAgBA,eAAe;QAACA;KAAa;AACpE"}
+{"version":3,"sources":["normalizeOpenItems.ts"],"sourcesContent":["export function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: false;\n  },\n): string[];\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined: true;\n  },\n): string[] | undefined;\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: boolean;\n  },\n): string[] | undefined {\n  if (!openSubtrees) {\n    return options?.keepUndefined ? undefined : [];\n  }\n  return Array.isArray(openSubtrees) ? openSubtrees : [openSubtrees];\n}\n"],"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"rangeMappings":";;;;;;;","mappings":"AAcA,OAAO,SAASA,mBACdC,YAAgC,EAChCC,OAEC;IAED,IAAI,CAACD,cAAc;QACjB,OAAOC,CAAAA,oBAAAA,8BAAAA,QAASC,aAAa,IAAGC,YAAY,EAAE;IAChD;IACA,OAAOC,MAAMC,OAAO,CAACL,gBAAgBA,eAAe;QAACA;KAAa;AACpE"}

package/lib/utils/tokens.js.map

@@ -1 +1 @@
-{"version":3,"sources":["tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nimport { TreeCheckedChangeData, TreeNavigationData_unstable, TreeOpenChangeData } from '../Tree';\n\nexport const treeItemLevelToken = '--fluent-TreeItem--level' as const;\n\nexport const treeAvatarSize = {\n  medium: 32,\n  small: 24,\n} as const;\n\nexport const treeDataTypes: {\n  readonly [K in TreeOpenChangeData['type'] | TreeNavigationData_unstable['type'] | TreeCheckedChangeData['type']]: K;\n} = {\n  ArrowLeft,\n  ArrowRight,\n  Enter,\n  Click: 'Click',\n  ExpandIconClick: 'ExpandIconClick',\n  End,\n  Home,\n  ArrowUp,\n  ArrowDown,\n  TypeAhead: 'TypeAhead',\n  Change: 'Change',\n};\n"],"names":["ArrowDown","ArrowLeft","ArrowRight","ArrowUp","End","Home","Enter","treeItemLevelToken","treeAvatarSize","medium","small","treeDataTypes","Click","ExpandIconClick","TypeAhead","Change"],"mappings":"AAAA,SAASA,SAAS,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,QAAQ,0BAA0B;AAGtG,OAAO,MAAMC,qBAAqB,2BAAoC;AAEtE,OAAO,MAAMC,iBAAiB;IAC5BC,QAAQ;IACRC,OAAO;AACT,EAAW;AAEX,OAAO,MAAMC,gBAET;IACFV;IACAC;IACAI;IACAM,OAAO;IACPC,iBAAiB;IACjBT;IACAC;IACAF;IACAH;IACAc,WAAW;IACXC,QAAQ;AACV,EAAE"}
+{"version":3,"sources":["tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nimport { TreeCheckedChangeData, TreeNavigationData_unstable, TreeOpenChangeData } from '../Tree';\n\nexport const treeItemLevelToken = '--fluent-TreeItem--level' as const;\n\nexport const treeAvatarSize = {\n  medium: 32,\n  small: 24,\n} as const;\n\nexport const treeDataTypes: {\n  readonly [K in TreeOpenChangeData['type'] | TreeNavigationData_unstable['type'] | TreeCheckedChangeData['type']]: K;\n} = {\n  ArrowLeft,\n  ArrowRight,\n  Enter,\n  Click: 'Click',\n  ExpandIconClick: 'ExpandIconClick',\n  End,\n  Home,\n  ArrowUp,\n  ArrowDown,\n  TypeAhead: 'TypeAhead',\n  Change: 'Change',\n};\n"],"names":["ArrowDown","ArrowLeft","ArrowRight","ArrowUp","End","Home","Enter","treeItemLevelToken","treeAvatarSize","medium","small","treeDataTypes","Click","ExpandIconClick","TypeAhead","Change"],"rangeMappings":";;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,SAAS,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,EAAEC,KAAK,QAAQ,0BAA0B;AAGtG,OAAO,MAAMC,qBAAqB,2BAAoC;AAEtE,OAAO,MAAMC,iBAAiB;IAC5BC,QAAQ;IACRC,OAAO;AACT,EAAW;AAEX,OAAO,MAAMC,gBAET;IACFV;IACAC;IACAI;IACAM,OAAO;IACPC,iBAAiB;IACjBT;IACAC;IACAF;IACAH;IACAc,WAAW;IACXC,QAAQ;AACV,EAAE"}

package/lib/utils/treeItemFilter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["treeItemFilter.ts"],"sourcesContent":["export const treeItemFilter = (element: HTMLElement) => {\n  return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n};\n"],"names":["treeItemFilter","element","getAttribute","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"mappings":"AAAA,OAAO,MAAMA,iBAAiB,CAACC;IAC7B,OAAOA,QAAQC,YAAY,CAAC,YAAY,aAAaC,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACxG,EAAE"}
+{"version":3,"sources":["treeItemFilter.ts"],"sourcesContent":["export const treeItemFilter = (element: HTMLElement) => {\n  return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n};\n"],"names":["treeItemFilter","element","getAttribute","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"rangeMappings":";;","mappings":"AAAA,OAAO,MAAMA,iBAAiB,CAACC;IAC7B,OAAOA,QAAQC,YAAY,CAAC,YAAY,aAAaC,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACxG,EAAE"}

package/lib-commonjs/FlatTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["FlatTree.js"],"sourcesContent":["export * from './components/FlatTree/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["FlatTree.ts"],"sourcesContent":["export * from './components/FlatTree/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/FlatTreeItem.js.map

@@ -1 +1 @@
-{"version":3,"sources":["FlatTreeItem.js"],"sourcesContent":["export * from './components/FlatTreeItem/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["FlatTreeItem.ts"],"sourcesContent":["export * from './components/FlatTreeItem/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/Tree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["Tree.js"],"sourcesContent":["export * from './components/Tree/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["Tree.ts"],"sourcesContent":["export * from './components/Tree/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/TreeItem.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TreeItem.js"],"sourcesContent":["export * from './components/TreeItem/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["TreeItem.ts"],"sourcesContent":["export * from './components/TreeItem/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/TreeItemLayout.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TreeItemLayout.js"],"sourcesContent":["export * from './components/TreeItemLayout/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["TreeItemLayout.ts"],"sourcesContent":["export * from './components/TreeItemLayout/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/TreeItemPersonaLayout.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TreeItemPersonaLayout.js"],"sourcesContent":["export * from './components/TreeItemPersonaLayout/index';\n"],"names":[],"mappings":";;;;;uBAAc"}
+{"version":3,"sources":["TreeItemPersonaLayout.ts"],"sourcesContent":["export * from './components/TreeItemPersonaLayout/index';\n"],"names":[],"rangeMappings":";;;;;","mappings":";;;;;uBAAc"}

package/lib-commonjs/components/FlatTree/FlatTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["FlatTree.js"],"sourcesContent":["import * as React from 'react';\nimport { useFlatTree_unstable } from './useFlatTree';\nimport { useFlatTreeStyles_unstable } from './useFlatTreeStyles.styles';\nimport { useFlatTreeContextValues_unstable } from './useFlatTreeContextValues';\nimport { renderFlatTree_unstable } from './renderFlatTree';\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 */ export const FlatTree = /*#__PURE__*/ React.forwardRef((props, ref)=>{\n    const state = useFlatTree_unstable(props, ref);\n    const contextValues = useFlatTreeContextValues_unstable(state);\n    useFlatTreeStyles_unstable(state);\n    return renderFlatTree_unstable(state, contextValues);\n});\nFlatTree.displayName = 'FlatTree';\n"],"names":["FlatTree","React","forwardRef","props","ref","state","useFlatTree_unstable","contextValues","useFlatTreeContextValues_unstable","useFlatTreeStyles_unstable","renderFlatTree_unstable","displayName"],"mappings":";;;;+BAUiBA;;;eAAAA;;;;iEAVM;6BACc;yCACM;0CACO;gCACV;AAM7B,MAAMA,WAAW,WAAW,GAAGC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC/D,MAAMC,QAAQC,IAAAA,iCAAoB,EAACH,OAAOC;IAC1C,MAAMG,gBAAgBC,IAAAA,2DAAiC,EAACH;IACxDI,IAAAA,mDAA0B,EAACJ;IAC3B,OAAOK,IAAAA,uCAAuB,EAACL,OAAOE;AAC1C;AACAP,SAASW,WAAW,GAAG"}
+{"version":3,"sources":["FlatTree.tsx"],"sourcesContent":["import * 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';\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  return renderFlatTree_unstable(state, contextValues);\n});\n\nFlatTree.displayName = 'FlatTree';\n"],"names":["FlatTree","React","forwardRef","props","ref","state","useFlatTree_unstable","contextValues","useFlatTreeContextValues_unstable","useFlatTreeStyles_unstable","renderFlatTree_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAcaA;;;eAAAA;;;;iEAdU;6BAGc;yCACM;0CACO;gCACV;AAQjC,MAAMA,WAAAA,WAAAA,GAA+CC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACnF,MAAMC,QAAQC,IAAAA,iCAAAA,EAAqBH,OAAOC;IAC1C,MAAMG,gBAAgBC,IAAAA,2DAAAA,EAAkCH;IACxDI,IAAAA,mDAAAA,EAA2BJ;IAC3B,OAAOK,IAAAA,uCAAAA,EAAwBL,OAAOE;AACxC;AAEAP,SAASW,WAAW,GAAG"}

package/lib-commonjs/components/FlatTree/FlatTree.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":""}
+{"version":3,"sources":["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   * 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":[],"rangeMappings":"","mappings":""}

package/lib-commonjs/components/FlatTree/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './FlatTree';\nexport * from './FlatTree.types';\nexport * from './useHeadlessFlatTree';\nexport * from './useFlatTree';\nexport * from './useFlatTreeStyles.styles';\nexport * from './useFlatTreeContextValues';\nexport * from './renderFlatTree';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './FlatTree';\nexport * from './FlatTree.types';\nexport * from './useHeadlessFlatTree';\nexport * from './useFlatTree';\nexport * from './useFlatTreeStyles.styles';\nexport * from './useFlatTreeContextValues';\nexport * from './renderFlatTree';\n"],"names":[],"rangeMappings":";;;;;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA;uBACA"}

package/lib-commonjs/components/FlatTree/renderFlatTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["renderFlatTree.js"],"sourcesContent":["import { renderTree_unstable } from '../../Tree';\nexport const renderFlatTree_unstable = renderTree_unstable;\n"],"names":["renderFlatTree_unstable","renderTree_unstable"],"mappings":";;;;+BACaA;;;eAAAA;;;sBADuB;AAC7B,MAAMA,0BAA0BC,yBAAmB"}
+{"version":3,"sources":["renderFlatTree.ts"],"sourcesContent":["import { renderTree_unstable } from '../../Tree';\nimport type { FlatTreeContextValues, FlatTreeState } from './FlatTree.types';\n\nexport const renderFlatTree_unstable: (state: FlatTreeState, contextValues: FlatTreeContextValues) => JSX.Element =\n  renderTree_unstable;\n"],"names":["renderFlatTree_unstable","renderTree_unstable"],"rangeMappings":";;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;sBAHuB;AAG7B,MAAMA,0BACXC,yBAAAA"}

package/lib-commonjs/components/FlatTree/useFlatControllableCheckedItems.js

@@ -9,11 +9,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    useFlatControllableCheckedItems: function() {
-        return useFlatControllableCheckedItems;
-    },
     createNextFlatCheckedItems: function() {
         return createNextFlatCheckedItems;
+    },
+    useFlatControllableCheckedItems: function() {
+        return useFlatControllableCheckedItems;
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");

package/lib-commonjs/components/FlatTree/useFlatControllableCheckedItems.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useFlatControllableCheckedItems.js"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport * as React from 'react';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nexport function useFlatControllableCheckedItems(props, headlessTree) {\n    return useControllableState({\n        initialState: ImmutableMap.empty,\n        state: React.useMemo(()=>props.selectionMode ? props.checkedItems && createCheckedItems(props.checkedItems) : undefined, [\n            props.checkedItems,\n            props.selectionMode\n        ]),\n        defaultState: ()=>initializeCheckedItems(props, headlessTree)\n    });\n}\nexport function createNextFlatCheckedItems(data, previousCheckedItems, headlessTree) {\n    if (data.selectionMode === 'single') {\n        return ImmutableMap.create([\n            [\n                data.value,\n                data.checked\n            ]\n        ]);\n    }\n    const treeItem = headlessTree.get(data.value);\n    if (!treeItem) {\n        if (process.env.NODE_ENV !== 'production') {\n            // eslint-disable-next-line no-console\n            console.error(`@fluentui/react-tree [useHeadlessFlatTree]:\nTree item ${data.value} not found.`);\n        }\n        return previousCheckedItems;\n    }\n    const nextCheckedItems = new Map(previousCheckedItems);\n    for (const children of headlessTree.subtree(data.value)){\n        nextCheckedItems.set(children.value, data.checked);\n    }\n    nextCheckedItems.set(data.value, data.checked);\n    let isAncestorsMixed = false;\n    for (const parent of headlessTree.ancestors(treeItem.value)){\n        // if one parent is mixed, all ancestors are mixed\n        if (isAncestorsMixed) {\n            nextCheckedItems.set(parent.value, 'mixed');\n            continue;\n        }\n        const checkedChildren = [];\n        for (const child of headlessTree.children(parent.value)){\n            var _nextCheckedItems_get;\n            if (((_nextCheckedItems_get = nextCheckedItems.get(child.value)) !== null && _nextCheckedItems_get !== void 0 ? _nextCheckedItems_get : false) === data.checked) {\n                checkedChildren.push(child);\n            }\n        }\n        if (checkedChildren.length === parent.childrenValues.length) {\n            nextCheckedItems.set(parent.value, data.checked);\n        } else {\n            // if one parent is mixed, all ancestors are mixed\n            isAncestorsMixed = true;\n            nextCheckedItems.set(parent.value, 'mixed');\n        }\n    }\n    return ImmutableMap.dangerouslyCreate_unstable(nextCheckedItems);\n}\nfunction initializeCheckedItems(props, headlessTree) {\n    if (!props.selectionMode) {\n        return ImmutableMap.empty;\n    }\n    let state = createCheckedItems(props.defaultCheckedItems);\n    if (props.selectionMode === 'multiselect') {\n        for (const [value, checked] of state){\n            state = createNextFlatCheckedItems({\n                value,\n                checked,\n                selectionMode: props.selectionMode\n            }, state, headlessTree);\n        }\n    }\n    return state;\n}\n"],"names":["useFlatControllableCheckedItems","createNextFlatCheckedItems","props","headlessTree","useControllableState","initialState","ImmutableMap","empty","state","React","useMemo","selectionMode","checkedItems","createCheckedItems","undefined","defaultState","initializeCheckedItems","data","previousCheckedItems","create","value","checked","treeItem","get","process","env","NODE_ENV","console","error","nextCheckedItems","Map","children","subtree","set","isAncestorsMixed","parent","ancestors","checkedChildren","child","_nextCheckedItems_get","push","length","childrenValues","dangerouslyCreate_unstable","defaultCheckedItems"],"mappings":";;;;;;;;;;;IAIgBA,+BAA+B;eAA/BA;;IAUAC,0BAA0B;eAA1BA;;;;gCAdqB;8BACR;iEACN;oCACY;AAC5B,SAASD,gCAAgCE,KAAK,EAAEC,YAAY;IAC/D,OAAOC,IAAAA,oCAAoB,EAAC;QACxBC,cAAcC,0BAAY,CAACC,KAAK;QAChCC,OAAOC,OAAMC,OAAO,CAAC,IAAIR,MAAMS,aAAa,GAAGT,MAAMU,YAAY,IAAIC,IAAAA,sCAAkB,EAACX,MAAMU,YAAY,IAAIE,WAAW;YACrHZ,MAAMU,YAAY;YAClBV,MAAMS,aAAa;SACtB;QACDI,cAAc,IAAIC,uBAAuBd,OAAOC;IACpD;AACJ;AACO,SAASF,2BAA2BgB,IAAI,EAAEC,oBAAoB,EAAEf,YAAY;IAC/E,IAAIc,KAAKN,aAAa,KAAK,UAAU;QACjC,OAAOL,0BAAY,CAACa,MAAM,CAAC;YACvB;gBACIF,KAAKG,KAAK;gBACVH,KAAKI,OAAO;aACf;SACJ;IACL;IACA,MAAMC,WAAWnB,aAAaoB,GAAG,CAACN,KAAKG,KAAK;IAC5C,IAAI,CAACE,UAAU;QACX,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACvC,sCAAsC;YACtCC,QAAQC,KAAK,CAAC,CAAC;UACjB,EAAEX,KAAKG,KAAK,CAAC,WAAW,CAAC;QAC3B;QACA,OAAOF;IACX;IACA,MAAMW,mBAAmB,IAAIC,IAAIZ;IACjC,KAAK,MAAMa,YAAY5B,aAAa6B,OAAO,CAACf,KAAKG,KAAK,EAAE;QACpDS,iBAAiBI,GAAG,CAACF,SAASX,KAAK,EAAEH,KAAKI,OAAO;IACrD;IACAQ,iBAAiBI,GAAG,CAAChB,KAAKG,KAAK,EAAEH,KAAKI,OAAO;IAC7C,IAAIa,mBAAmB;IACvB,KAAK,MAAMC,UAAUhC,aAAaiC,SAAS,CAACd,SAASF,KAAK,EAAE;QACxD,kDAAkD;QAClD,IAAIc,kBAAkB;YAClBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;YACnC;QACJ;QACA,MAAMiB,kBAAkB,EAAE;QAC1B,KAAK,MAAMC,SAASnC,aAAa4B,QAAQ,CAACI,OAAOf,KAAK,EAAE;YACpD,IAAImB;YACJ,IAAI,AAAC,CAAA,AAACA,CAAAA,wBAAwBV,iBAAiBN,GAAG,CAACe,MAAMlB,KAAK,CAAA,MAAO,QAAQmB,0BAA0B,KAAK,IAAIA,wBAAwB,KAAI,MAAOtB,KAAKI,OAAO,EAAE;gBAC7JgB,gBAAgBG,IAAI,CAACF;YACzB;QACJ;QACA,IAAID,gBAAgBI,MAAM,KAAKN,OAAOO,cAAc,CAACD,MAAM,EAAE;YACzDZ,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAEH,KAAKI,OAAO;QACnD,OAAO;YACH,kDAAkD;YAClDa,mBAAmB;YACnBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;QACvC;IACJ;IACA,OAAOd,0BAAY,CAACqC,0BAA0B,CAACd;AACnD;AACA,SAASb,uBAAuBd,KAAK,EAAEC,YAAY;IAC/C,IAAI,CAACD,MAAMS,aAAa,EAAE;QACtB,OAAOL,0BAAY,CAACC,KAAK;IAC7B;IACA,IAAIC,QAAQK,IAAAA,sCAAkB,EAACX,MAAM0C,mBAAmB;IACxD,IAAI1C,MAAMS,aAAa,KAAK,eAAe;QACvC,KAAK,MAAM,CAACS,OAAOC,QAAQ,IAAIb,MAAM;YACjCA,QAAQP,2BAA2B;gBAC/BmB;gBACAC;gBACAV,eAAeT,MAAMS,aAAa;YACtC,GAAGH,OAAOL;QACd;IACJ;IACA,OAAOK;AACX"}
+{"version":3,"sources":["useFlatControllableCheckedItems.ts"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport { TreeItemValue } from '../../TreeItem';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport * as React from 'react';\nimport type { HeadlessTree, HeadlessTreeItemProps } from '../../utils/createHeadlessTree';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nimport type { TreeCheckedChangeData } from '../Tree/Tree.types';\nimport { HeadlessFlatTreeOptions } from './useHeadlessFlatTree';\n\nexport function useFlatControllableCheckedItems<Props extends HeadlessTreeItemProps>(\n  props: Pick<HeadlessFlatTreeOptions, 'checkedItems' | 'defaultCheckedItems' | 'selectionMode'>,\n  headlessTree: HeadlessTree<Props>,\n) {\n  return useControllableState({\n    initialState: ImmutableMap.empty,\n    state: React.useMemo(\n      () => (props.selectionMode ? props.checkedItems && createCheckedItems(props.checkedItems) : undefined),\n      [props.checkedItems, props.selectionMode],\n    ),\n    defaultState: () => initializeCheckedItems(props, headlessTree),\n  });\n}\n\nexport function createNextFlatCheckedItems(\n  data: Pick<TreeCheckedChangeData, 'value' | 'checked' | 'selectionMode'>,\n  previousCheckedItems: ImmutableMap<TreeItemValue, 'mixed' | boolean>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n): ImmutableMap<TreeItemValue, 'mixed' | boolean> {\n  if (data.selectionMode === 'single') {\n    return ImmutableMap.create([[data.value, data.checked]]);\n  }\n  const treeItem = headlessTree.get(data.value);\n  if (!treeItem) {\n    if (process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line no-console\n      console.error(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useHeadlessFlatTree]:\n        Tree item ${data.value} not found.\n      `);\n    }\n    return previousCheckedItems;\n  }\n  const nextCheckedItems = new Map(previousCheckedItems);\n  for (const children of headlessTree.subtree(data.value)) {\n    nextCheckedItems.set(children.value, data.checked);\n  }\n  nextCheckedItems.set(data.value, data.checked);\n\n  let isAncestorsMixed = false;\n  for (const parent of headlessTree.ancestors(treeItem.value)) {\n    // if one parent is mixed, all ancestors are mixed\n    if (isAncestorsMixed) {\n      nextCheckedItems.set(parent.value, 'mixed');\n      continue;\n    }\n    const checkedChildren = [];\n    for (const child of headlessTree.children(parent.value)) {\n      if ((nextCheckedItems.get(child.value) ?? false) === data.checked) {\n        checkedChildren.push(child);\n      }\n    }\n    if (checkedChildren.length === parent.childrenValues.length) {\n      nextCheckedItems.set(parent.value, data.checked);\n    } else {\n      // if one parent is mixed, all ancestors are mixed\n      isAncestorsMixed = true;\n      nextCheckedItems.set(parent.value, 'mixed');\n    }\n  }\n  return ImmutableMap.dangerouslyCreate_unstable(nextCheckedItems);\n}\n\nfunction initializeCheckedItems(\n  props: Pick<HeadlessFlatTreeOptions, 'selectionMode' | 'defaultCheckedItems'>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n) {\n  if (!props.selectionMode) {\n    return ImmutableMap.empty;\n  }\n  let state = createCheckedItems(props.defaultCheckedItems);\n  if (props.selectionMode === 'multiselect') {\n    for (const [value, checked] of state) {\n      state = createNextFlatCheckedItems({ value, checked, selectionMode: props.selectionMode }, state, headlessTree);\n    }\n  }\n  return state;\n}\n"],"names":["createNextFlatCheckedItems","useFlatControllableCheckedItems","props","headlessTree","useControllableState","initialState","ImmutableMap","empty","state","React","useMemo","selectionMode","checkedItems","createCheckedItems","undefined","defaultState","initializeCheckedItems","data","previousCheckedItems","create","value","checked","treeItem","get","process","env","NODE_ENV","console","error","nextCheckedItems","Map","children","subtree","set","isAncestorsMixed","parent","ancestors","checkedChildren","child","push","length","childrenValues","dangerouslyCreate_unstable","defaultCheckedItems"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAuBgBA,0BAAAA;eAAAA;;IAdAC,+BAAAA;eAAAA;;;;gCATqB;8BAER;iEACN;oCAEY;AAI5B,SAASA,gCACdC,KAA8F,EAC9FC,YAAiC;IAEjC,OAAOC,IAAAA,oCAAAA,EAAqB;QAC1BC,cAAcC,0BAAAA,CAAaC,KAAK;QAChCC,OAAOC,OAAMC,OAAO,CAClB,IAAOR,MAAMS,aAAa,GAAGT,MAAMU,YAAY,IAAIC,IAAAA,sCAAAA,EAAmBX,MAAMU,YAAY,IAAIE,WAC5F;YAACZ,MAAMU,YAAY;YAAEV,MAAMS,aAAa;SAAC;QAE3CI,cAAc,IAAMC,uBAAuBd,OAAOC;IACpD;AACF;AAEO,SAASH,2BACdiB,IAAwE,EACxEC,oBAAoE,EACpEf,YAAiD;IAEjD,IAAIc,KAAKN,aAAa,KAAK,UAAU;QACnC,OAAOL,0BAAAA,CAAaa,MAAM,CAAC;YAAC;gBAACF,KAAKG,KAAK;gBAAEH,KAAKI,OAAO;aAAC;SAAC;IACzD;IACA,MAAMC,WAAWnB,aAAaoB,GAAG,CAACN,KAAKG,KAAK;IAC5C,IAAI,CAACE,UAAU;QACb,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,sCAAsC;YACtCC,QAAQC,KAAK,CAAsB,CAAC;UAExB,EAAEX,KAAKG,KAAK,CAAC,WACzB,CAAC;QACH;QACA,OAAOF;IACT;IACA,MAAMW,mBAAmB,IAAIC,IAAIZ;IACjC,KAAK,MAAMa,YAAY5B,aAAa6B,OAAO,CAACf,KAAKG,KAAK,EAAG;QACvDS,iBAAiBI,GAAG,CAACF,SAASX,KAAK,EAAEH,KAAKI,OAAO;IACnD;IACAQ,iBAAiBI,GAAG,CAAChB,KAAKG,KAAK,EAAEH,KAAKI,OAAO;IAE7C,IAAIa,mBAAmB;IACvB,KAAK,MAAMC,UAAUhC,aAAaiC,SAAS,CAACd,SAASF,KAAK,EAAG;QAC3D,kDAAkD;QAClD,IAAIc,kBAAkB;YACpBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;YACnC;QACF;QACA,MAAMiB,kBAAkB,EAAE;QAC1B,KAAK,MAAMC,SAASnC,aAAa4B,QAAQ,CAACI,OAAOf,KAAK,EAAG;gBAClDS;YAAL,IAAI,AAACA,CAAAA,CAAAA,wBAAAA,iBAAiBN,GAAG,CAACe,MAAMlB,KAAK,CAAA,MAAA,QAAhCS,0BAAAA,KAAAA,IAAAA,wBAAqC,KAAA,MAAWZ,KAAKI,OAAO,EAAE;gBACjEgB,gBAAgBE,IAAI,CAACD;YACvB;QACF;QACA,IAAID,gBAAgBG,MAAM,KAAKL,OAAOM,cAAc,CAACD,MAAM,EAAE;YAC3DX,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAEH,KAAKI,OAAO;QACjD,OAAO;YACL,kDAAkD;YAClDa,mBAAmB;YACnBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;QACrC;IACF;IACA,OAAOd,0BAAAA,CAAaoC,0BAA0B,CAACb;AACjD;AAEA,SAASb,uBACPd,KAA6E,EAC7EC,YAAiD;IAEjD,IAAI,CAACD,MAAMS,aAAa,EAAE;QACxB,OAAOL,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAIC,QAAQK,IAAAA,sCAAAA,EAAmBX,MAAMyC,mBAAmB;IACxD,IAAIzC,MAAMS,aAAa,KAAK,eAAe;QACzC,KAAK,MAAM,CAACS,OAAOC,QAAQ,IAAIb,MAAO;YACpCA,QAAQR,2BAA2B;gBAAEoB;gBAAOC;gBAASV,eAAeT,MAAMS,aAAa;YAAC,GAAGH,OAAOL;QACpG;IACF;IACA,OAAOK;AACT"}

package/lib-commonjs/components/FlatTree/useFlatTree.js

@@ -18,6 +18,7 @@ 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

package/lib-commonjs/components/FlatTree/useFlatTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useFlatTree.js"],"sourcesContent":["import * as React from 'react';\nimport { useRootTree } from '../../hooks/useRootTree';\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';\nexport const useFlatTree_unstable = (props, ref)=>{\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};\nfunction useRootFlatTree(props, ref) {\n    const navigation = useFlatTreeNavigation();\n    return Object.assign(useRootTree({\n        ...props,\n        onNavigation: useEventCallback((event, data)=>{\n            var _props_onNavigation;\n            (_props_onNavigation = props.onNavigation) === null || _props_onNavigation === void 0 ? void 0 : _props_onNavigation.call(props, event, data);\n            if (!event.isDefaultPrevented()) {\n                navigation.navigate(data);\n            }\n        })\n    }, useMergedRefs(ref, navigation.rootRef)), {\n        treeType: 'flat'\n    });\n}\nfunction useSubFlatTree(props, ref) {\n    if (process.env.NODE_ENV === 'development') {\n        throw new Error(`@fluentui/react-tree [useFlatTree]:\nSubtrees are not allowed in a FlatTree!\nYou cannot use a <FlatTree> component inside of another <FlatTree> nor a <Tree> component!`);\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        appearance: 'subtle',\n        size: 'medium',\n        // ------ defaultTreeContextValue\n        open: false\n    };\n}\nfunction noop() {\n/* do nothing */ }\n"],"names":["useFlatTree_unstable","props","ref","isRoot","React","useContext","SubtreeContext","undefined","useRootFlatTree","useSubFlatTree","navigation","useFlatTreeNavigation","Object","assign","useRootTree","onNavigation","useEventCallback","event","data","_props_onNavigation","call","isDefaultPrevented","navigate","useMergedRefs","rootRef","treeType","process","env","NODE_ENV","Error","useSubtree","level","contextType","selectionMode","openItems","ImmutableSet","empty","checkedItems","ImmutableMap","requestTreeResponse","noop","appearance","size","open"],"mappings":";;;;+BAQaA;;;eAAAA;;;;iEARU;6BACK;gCACoB;uCACV;4BACX;8BACE;8BACA;gCACE;AACxB,MAAMA,uBAAuB,CAACC,OAAOC;IACxC,MAAMC,SAASC,OAAMC,UAAU,CAACC,8BAAc,MAAMC;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOJ,SAASK,gBAAgBP,OAAOC,OAAOO,eAAeR,OAAOC;AACxE;AACA,SAASM,gBAAgBP,KAAK,EAAEC,GAAG;IAC/B,MAAMQ,aAAaC,IAAAA,4CAAqB;IACxC,OAAOC,OAAOC,MAAM,CAACC,IAAAA,wBAAW,EAAC;QAC7B,GAAGb,KAAK;QACRc,cAAcC,IAAAA,gCAAgB,EAAC,CAACC,OAAOC;YACnC,IAAIC;YACHA,CAAAA,sBAAsBlB,MAAMc,YAAY,AAAD,MAAO,QAAQI,wBAAwB,KAAK,IAAI,KAAK,IAAIA,oBAAoBC,IAAI,CAACnB,OAAOgB,OAAOC;YACxI,IAAI,CAACD,MAAMI,kBAAkB,IAAI;gBAC7BX,WAAWY,QAAQ,CAACJ;YACxB;QACJ;IACJ,GAAGK,IAAAA,6BAAa,EAACrB,KAAKQ,WAAWc,OAAO,IAAI;QACxCC,UAAU;IACd;AACJ;AACA,SAAShB,eAAeR,KAAK,EAAEC,GAAG;IAC9B,IAAIwB,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QACxC,MAAM,IAAIC,MAAM,CAAC;;0FAEiE,CAAC;IACvF;IACA,OAAO;QACH,GAAGC,IAAAA,sBAAU,EAAC7B,OAAOC,IAAI;QACzB,iCAAiC;QACjC6B,OAAO;QACPC,aAAa;QACbP,UAAU;QACVQ,eAAe;QACfC,WAAWC,0BAAY,CAACC,KAAK;QAC7BC,cAAcC,0BAAY,CAACF,KAAK;QAChCG,qBAAqBC;QACrBC,YAAY;QACZC,MAAM;QACN,iCAAiC;QACjCC,MAAM;IACV;AACJ;AACA,SAASH;AACT,cAAc,GAAG"}
+{"version":3,"sources":["useFlatTree.ts"],"sourcesContent":["import * 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();\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    { treeType: 'flat' } 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    appearance: 'subtle',\n    size: 'medium',\n    // ------ defaultTreeContextValue\n    open: false,\n  };\n}\n\nfunction noop() {\n  /* do nothing */\n}\n"],"names":["useFlatTree_unstable","props","ref","isRoot","React","useContext","SubtreeContext","undefined","useRootFlatTree","useSubFlatTree","navigation","useFlatTreeNavigation","Object","assign","useRootTree","onNavigation","useEventCallback","event","data","isDefaultPrevented","navigate","useMergedRefs","rootRef","treeType","process","env","NODE_ENV","Error","useSubtree","level","contextType","selectionMode","openItems","ImmutableSet","empty","checkedItems","ImmutableMap","requestTreeResponse","noop","appearance","size","open"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAUaA;;;eAAAA;;;;iEAVU;6BACK;gCAEoB;uCACV;4BACX;8BACE;8BACA;gCACE;AAExB,MAAMA,uBAA6F,CACxGC,OACAC;IAEA;IAEA,MAAMC,SAASC,OAAMC,UAAU,CAACC,8BAAAA,MAAoBC;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOJ,SAASK,gBAAgBP,OAAOC,OAAOO,eAAeR,OAAOC;AACtE;AAEA,SAASM,gBAAgBP,KAAoB,EAAEC,GAA2B;IACxE,MAAMQ,aAAaC,IAAAA,4CAAAA;IAEnB,OAAOC,OAAOC,MAAM,CAClBC,IAAAA,wBAAAA,EACE;QACE,GAAGb,KAAK;QACRc,cAAcC,IAAAA,gCAAAA,EAAiB,CAACC,OAAOC;gBACrCjB;YAAAA,CAAAA,sBAAAA,MAAMc,YAAY,AAAZA,MAAY,QAAlBd,wBAAAA,KAAAA,IAAAA,KAAAA,IAAAA,oBAAAA,IAAAA,CAAAA,OAAqBgB,OAAOC;YAC5B,IAAI,CAACD,MAAME,kBAAkB,IAAI;gBAC/BT,WAAWU,QAAQ,CAACF;YACtB;QACF;IACF,GACAG,IAAAA,6BAAAA,EAAcnB,KAAKQ,WAAWY,OAAO,IAEvC;QAAEC,UAAU;IAAO;AAEvB;AAEA,SAASd,eAAeR,KAAoB,EAAEC,GAA2B;IACvE,IAAIsB,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC1C,MAAM,IAAIC,MAA2B,CAAC;;0FAItC,CAAC;IACH;IACA,OAAO;QACL,GAAGC,IAAAA,sBAAAA,EAAW3B,OAAOC,IAAI;QACzB,iCAAiC;QACjC2B,OAAO;QACPC,aAAa;QACbP,UAAU;QACVQ,eAAe;QACfC,WAAWC,0BAAAA,CAAaC,KAAK;QAC7BC,cAAcC,0BAAAA,CAAaF,KAAK;QAChCG,qBAAqBC;QACrBC,YAAY;QACZC,MAAM;QACN,iCAAiC;QACjCC,MAAM;IACR;AACF;AAEA,SAASH;AACP,cAAc,GAChB"}

package/lib-commonjs/components/FlatTree/useFlatTreeContextValues.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useFlatTreeContextValues.js"],"sourcesContent":["export const useFlatTreeContextValues_unstable = (state)=>{\n    const { openItems, level, contextType, treeType, checkedItems, selectionMode, appearance, size, requestTreeResponse } = state;\n    /**\n   * This context is created with \"@fluentui/react-context-selector\",\n   * there is no sense to memoize it\n   */ const tree = {\n        treeType,\n        size,\n        openItems,\n        appearance,\n        checkedItems,\n        selectionMode,\n        contextType,\n        level,\n        requestTreeResponse\n    };\n    return {\n        tree\n    };\n};\n"],"names":["useFlatTreeContextValues_unstable","state","openItems","level","contextType","treeType","checkedItems","selectionMode","appearance","size","requestTreeResponse","tree"],"mappings":";;;;+BAAaA;;;eAAAA;;;AAAN,MAAMA,oCAAoC,CAACC;IAC9C,MAAM,EAAEC,SAAS,EAAEC,KAAK,EAAEC,WAAW,EAAEC,QAAQ,EAAEC,YAAY,EAAEC,aAAa,EAAEC,UAAU,EAAEC,IAAI,EAAEC,mBAAmB,EAAE,GAAGT;IACxH;;;GAGD,GAAG,MAAMU,OAAO;QACXN;QACAI;QACAP;QACAM;QACAF;QACAC;QACAH;QACAD;QACAO;IACJ;IACA,OAAO;QACHC;IACJ;AACJ"}
+{"version":3,"sources":["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    appearance,\n    size,\n    requestTreeResponse,\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    contextType,\n    level,\n    requestTreeResponse,\n  };\n\n  return { tree };\n};\n"],"names":["useFlatTreeContextValues_unstable","state","openItems","level","contextType","treeType","checkedItems","selectionMode","appearance","size","requestTreeResponse","tree"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGaA;;;eAAAA;;;AAAN,MAAMA,oCAAoC,CAACC;IAChD,MAAM,EACJC,SAAS,EACTC,KAAK,EACLC,WAAW,EACXC,QAAQ,EACRC,YAAY,EACZC,aAAa,EACbC,UAAU,EACVC,IAAI,EACJC,mBAAmB,EACpB,GAAGT;IACJ;;;GAGC,GACD,MAAMU,OAAyB;QAC7BN;QACAI;QACAP;QACAM;QACAF;QACAC;QACAH;QACAD;QACAO;IACF;IAEA,OAAO;QAAEC;IAAK;AAChB"}

package/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.js

@@ -24,6 +24,7 @@ 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;

package/lib-commonjs/components/FlatTree/useFlatTreeStyles.styles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useFlatTreeStyles.styles.js"],"sourcesContent":["import { __resetStyles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const flatTreeClassNames = {\n  root: 'fui-FlatTree'\n};\nconst useBaseStyles = /*#__PURE__*/__resetStyles(\"rnv2ez3\", null, [\".rnv2ez3{display:flex;flex-direction:column;row-gap:var(--spacingVerticalXXS);}\"]);\nexport const useFlatTreeStyles_unstable = state => {\n  const baseStyles = useBaseStyles();\n  state.root.className = mergeClasses(flatTreeClassNames.root, baseStyles, state.root.className);\n  return state;\n};\n//# sourceMappingURL=useFlatTreeStyles.styles.js.map"],"names":["flatTreeClassNames","useFlatTreeStyles_unstable","root","useBaseStyles","__resetStyles","state","baseStyles","className","mergeClasses"],"mappings":";;;;;;;;;;;IAEaA,kBAAkB;eAAlBA;;IAIAC,0BAA0B;eAA1BA;;;uBAN+B;AAErC,MAAMD,qBAAqB;IAChCE,MAAM;AACR;AACA,MAAMC,gBAAgB,WAAW,GAAEC,IAAAA,oBAAa,EAAC,WAAW,MAAM;IAAC;CAAkF;AAC9I,MAAMH,6BAA6BI,CAAAA;IACxC,MAAMC,aAAaH;IACnBE,MAAMH,IAAI,CAACK,SAAS,GAAGC,IAAAA,mBAAY,EAACR,mBAAmBE,IAAI,EAAEI,YAAYD,MAAMH,IAAI,CAACK,SAAS;IAC7F,OAAOF;AACT,GACA,oDAAoD"}
+{"version":3,"sources":["useFlatTreeStyles.styles.js"],"sourcesContent":["import { 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":["flatTreeClassNames","useFlatTreeStyles_unstable","root","useBaseStyles","__resetStyles","state","baseStyles","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,kBAAkB;eAAlBA;;IAQAC,0BAA0B;eAA1BA;;;uBAViC;AAEvC,MAAMD,qBAAqB;IAC9BE,MAAM;AACV;AACA,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,oBAAA,EAAA,WAAA,MAAA;IAAA;CAIrB;AACM,MAAMH,6BAA8BI,CAAAA;IACvC;IACA,MAAMC,aAAaH;IACnBE,MAAMH,IAAI,CAACK,SAAS,GAAGC,IAAAA,mBAAY,EAACR,mBAAmBE,IAAI,EAAEI,YAAYD,MAAMH,IAAI,CAACK,SAAS;IAC7F,OAAOF;AACX"}

package/lib-commonjs/components/FlatTree/useHeadlessFlatTree.js

@@ -18,6 +18,7 @@ const _useControllableOpenItems = require("../../hooks/useControllableOpenItems"
 const _getTreeItemValueFromElement = require("../../utils/getTreeItemValueFromElement");
 const _useFlatControllableCheckedItems = require("./useFlatControllableCheckedItems");
 function useHeadlessFlatTree_unstable(props, options = {}) {
+    'use no memo';
     const headlessTree = _react.useMemo(()=>(0, _createHeadlessTree.createHeadlessTree)(props), [
         props
     ]);

package/lib-commonjs/components/FlatTree/useHeadlessFlatTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useHeadlessFlatTree.js"],"sourcesContent":["import { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { createHeadlessTree } from '../../utils/createHeadlessTree';\nimport { treeDataTypes } from '../../utils/tokens';\nimport { useFlatTreeNavigation } from '../../hooks/useFlatTreeNavigation';\nimport { createNextOpenItems, useControllableOpenItems } from '../../hooks/useControllableOpenItems';\nimport { dataTreeItemValueAttrName } from '../../utils/getTreeItemValueFromElement';\nimport { createNextFlatCheckedItems, useFlatControllableCheckedItems } from './useFlatControllableCheckedItems';\n/**\n * this hook provides FlatTree API to manage all required mechanisms to convert a list of items into renderable TreeItems\n * in multiple scenarios including virtualization.\n *\n * !!A flat tree is an unofficial spec for tree!!\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 *\n * @param props - a list of tree items\n * @param options - in case control over the internal openItems is required\n */ export function useHeadlessFlatTree_unstable(props, options = {}) {\n    const headlessTree = React.useMemo(()=>createHeadlessTree(props), [\n        props\n    ]);\n    const [openItems, setOpenItems] = useControllableOpenItems(options);\n    const [checkedItems, setCheckedItems] = useFlatControllableCheckedItems(options, headlessTree);\n    const navigation = useFlatTreeNavigation();\n    const treeRef = React.useRef(null);\n    const handleOpenChange = useEventCallback((event, data)=>{\n        var _options_onOpenChange;\n        const nextOpenItems = createNextOpenItems(data, openItems);\n        (_options_onOpenChange = options.onOpenChange) === null || _options_onOpenChange === void 0 ? void 0 : _options_onOpenChange.call(options, event, {\n            ...data,\n            openItems: nextOpenItems.dangerouslyGetInternalSet_unstable()\n        });\n        setOpenItems(nextOpenItems);\n    });\n    const handleCheckedChange = useEventCallback((event, data)=>{\n        var _options_onCheckedChange;\n        const nextCheckedItems = createNextFlatCheckedItems(data, checkedItems, headlessTree);\n        (_options_onCheckedChange = options.onCheckedChange) === null || _options_onCheckedChange === void 0 ? void 0 : _options_onCheckedChange.call(options, event, {\n            ...data,\n            checkedItems: nextCheckedItems.dangerouslyGetInternalMap_unstable()\n        });\n        setCheckedItems(nextCheckedItems);\n    });\n    const getNextNavigableItem = useEventCallback((visibleItems, data)=>{\n        const item = headlessTree.get(data.value);\n        if (item) {\n            switch(data.type){\n                case treeDataTypes.TypeAhead:\n                    return item;\n                case treeDataTypes.ArrowLeft:\n                    return headlessTree.get(item.parentValue);\n                case treeDataTypes.ArrowRight:\n                    return visibleItems[item.index + 1];\n                case treeDataTypes.End:\n                    return visibleItems[visibleItems.length - 1];\n                case treeDataTypes.Home:\n                    return visibleItems[0];\n                case treeDataTypes.ArrowDown:\n                    return visibleItems[item.index + 1];\n                case treeDataTypes.ArrowUp:\n                    return visibleItems[item.index - 1];\n            }\n        }\n    });\n    const getElementFromItem = React.useCallback((item)=>{\n        var _treeRef_current;\n        return (_treeRef_current = treeRef.current) === null || _treeRef_current === void 0 ? void 0 : _treeRef_current.querySelector(`[${dataTreeItemValueAttrName}=\"${item.value}\"]`);\n    }, []);\n    const ref = useMergedRefs(treeRef, navigation.rootRef);\n    const getTreeProps = React.useCallback(()=>{\n        var _options_onNavigation;\n        return {\n            ref,\n            openItems,\n            selectionMode: options.selectionMode,\n            checkedItems,\n            onOpenChange: handleOpenChange,\n            onCheckedChange: handleCheckedChange,\n            onNavigation: (_options_onNavigation = options.onNavigation) !== null && _options_onNavigation !== void 0 ? _options_onNavigation : noop\n        };\n    }, // ref, handleOpenChange - useEventCallback, handleCheckedChange - useEventCallback\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [\n        openItems,\n        checkedItems,\n        options.selectionMode,\n        options.onNavigation\n    ]);\n    const items = React.useCallback(()=>headlessTree.visibleItems(openItems), [\n        openItems,\n        headlessTree\n    ]);\n    const getItem = React.useCallback((value)=>headlessTree.get(value), [\n        headlessTree\n    ]);\n    return React.useMemo(()=>({\n            navigate: navigation.navigate,\n            getTreeProps,\n            getNextNavigableItem,\n            getElementFromItem,\n            items,\n            getItem\n        }), [\n        navigation.navigate,\n        getTreeProps,\n        getNextNavigableItem,\n        getElementFromItem,\n        items,\n        getItem\n    ]);\n}\n/** @internal */ function noop() {\n/* noop */ }\n"],"names":["useHeadlessFlatTree_unstable","props","options","headlessTree","React","useMemo","createHeadlessTree","openItems","setOpenItems","useControllableOpenItems","checkedItems","setCheckedItems","useFlatControllableCheckedItems","navigation","useFlatTreeNavigation","treeRef","useRef","handleOpenChange","useEventCallback","event","data","_options_onOpenChange","nextOpenItems","createNextOpenItems","onOpenChange","call","dangerouslyGetInternalSet_unstable","handleCheckedChange","_options_onCheckedChange","nextCheckedItems","createNextFlatCheckedItems","onCheckedChange","dangerouslyGetInternalMap_unstable","getNextNavigableItem","visibleItems","item","get","value","type","treeDataTypes","TypeAhead","ArrowLeft","parentValue","ArrowRight","index","End","length","Home","ArrowDown","ArrowUp","getElementFromItem","useCallback","_treeRef_current","current","querySelector","dataTreeItemValueAttrName","ref","useMergedRefs","rootRef","getTreeProps","_options_onNavigation","selectionMode","onNavigation","noop","items","getItem","navigate"],"mappings":"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"}
+{"version":3,"sources":["useHeadlessFlatTree.ts"],"sourcesContent":["import { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\nimport * as React from 'react';\nimport { HeadlessTreeItem, HeadlessTreeItemProps, createHeadlessTree } from '../../utils/createHeadlessTree';\nimport { treeDataTypes } from '../../utils/tokens';\nimport { useFlatTreeNavigation } from '../../hooks/useFlatTreeNavigation';\nimport { createNextOpenItems, useControllableOpenItems } from '../../hooks/useControllableOpenItems';\nimport type { TreeItemValue } from '../../TreeItem';\nimport { dataTreeItemValueAttrName } from '../../utils/getTreeItemValueFromElement';\nimport { ImmutableSet } from '../../utils/ImmutableSet';\nimport { createNextFlatCheckedItems, useFlatControllableCheckedItems } from './useFlatControllableCheckedItems';\nimport { FlatTreeProps } from './FlatTree.types';\nimport {\n  TreeCheckedChangeData,\n  TreeCheckedChangeEvent,\n  TreeNavigationData_unstable,\n  TreeOpenChangeData,\n  TreeOpenChangeEvent,\n  TreeProps,\n} from '../Tree/Tree.types';\n\nexport type HeadlessFlatTreeItemProps = HeadlessTreeItemProps;\nexport type HeadlessFlatTreeItem<Props extends HeadlessFlatTreeItemProps> = HeadlessTreeItem<Props>;\n\n/**\n * FlatTree API to manage all required mechanisms to convert a list of items into renderable TreeItems\n * in multiple scenarios including virtualization.\n *\n * !!A flat tree is an unofficial spec for tree!!\n *\n * It should be used on cases where more complex interactions with a Tree is required.\n *\n * On simple scenarios it is advised to simply use a nested structure instead.\n */\nexport type HeadlessFlatTree<Props extends HeadlessFlatTreeItemProps> = {\n  /**\n   * returns the properties required for the Tree component to work properly.\n   * That includes:\n   * `openItems`, `onOpenChange`, `onNavigation_unstable` and `ref`\n   */\n  getTreeProps(): Required<\n    Pick<FlatTreeProps, 'openItems' | 'onOpenChange' | 'onNavigation' | 'checkedItems' | 'onCheckedChange'>\n  > & {\n    ref: React.Ref<HTMLDivElement>;\n    openItems: ImmutableSet<TreeItemValue>;\n  };\n  /**\n   * internal method used to react to an `onNavigation` event.\n   * This method ensures proper navigation on keyboard and mouse interaction.\n   * In case of virtualization it might be required to cancel default provided `onNavigation`\n   * event and then call this method manually.\n   *\n   * @example\n   * ```ts\n   * // react-window\n   * const handleNavigation = (event, data) => {\n   *   event.preventDefault();\n   *   const nextItem = tree.getNextNavigableItem(data);\n   *   // scroll to item using virtualization scroll mechanism\n   *   if (nextItem && tree.getElementFromItem(nextItem)) {\n   *     listRef.current.scrollToItem(nextItem.index);\n   *   }\n   *   // wait for scrolling to happen and then invoke navigate method\n   *   requestAnimationFrame(() => {\n   *     tree.navigate(data);\n   *   });\n   * };\n   *```\n   */\n  navigate(data: TreeNavigationData_unstable): void;\n  /**\n   * returns next item to be focused on a navigation.\n   * This method is provided to decouple the element that needs to be focused from\n   *  the action of focusing it itself.\n   *\n   * On the case of TypeAhead navigation this method returns the current item.\n   */\n  getNextNavigableItem(\n    visibleItems: HeadlessTreeItem<Props>[],\n    data: TreeNavigationData_unstable,\n  ): HeadlessTreeItem<Props> | undefined;\n  /**\n   * similar to getElementById but for FlatTreeItems\n   */\n  getElementFromItem(item: HeadlessTreeItem<Props>): HTMLElement | null;\n  /**\n   * an iterable containing all visually available flat tree items\n   */\n  items(): IterableIterator<HeadlessTreeItem<Props>>;\n};\n\nexport type HeadlessFlatTreeOptions = Pick<\n  FlatTreeProps,\n  'onOpenChange' | 'onNavigation' | 'selectionMode' | 'onCheckedChange'\n> &\n  Pick<TreeProps, 'defaultOpenItems' | 'openItems' | 'checkedItems'> & {\n    defaultCheckedItems?: TreeProps['checkedItems'];\n  };\n\n/**\n * @internal\n */\ntype HeadlessFlatTreeReturn<Props extends HeadlessFlatTreeItemProps> = HeadlessFlatTree<Props> & {\n  getItem(value: TreeItemValue): HeadlessTreeItem<Props> | undefined;\n};\n\n/**\n * this hook provides FlatTree API to manage all required mechanisms to convert a list of items into renderable TreeItems\n * in multiple scenarios including virtualization.\n *\n * !!A flat tree is an unofficial spec for tree!!\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 *\n * @param props - a list of tree items\n * @param options - in case control over the internal openItems is required\n */\nexport function useHeadlessFlatTree_unstable<Props extends HeadlessTreeItemProps>(\n  props: Props[],\n  options: HeadlessFlatTreeOptions = {},\n): HeadlessFlatTreeReturn<Props> {\n  'use no memo';\n\n  const headlessTree = React.useMemo(() => createHeadlessTree(props), [props]);\n  const [openItems, setOpenItems] = useControllableOpenItems(options);\n  const [checkedItems, setCheckedItems] = useFlatControllableCheckedItems(options, headlessTree);\n  const navigation = useFlatTreeNavigation();\n\n  const treeRef = React.useRef<HTMLDivElement>(null);\n  const handleOpenChange = useEventCallback((event: TreeOpenChangeEvent, data: TreeOpenChangeData) => {\n    const nextOpenItems = createNextOpenItems(data, openItems);\n    options.onOpenChange?.(event, {\n      ...data,\n      openItems: nextOpenItems.dangerouslyGetInternalSet_unstable(),\n    });\n    setOpenItems(nextOpenItems);\n  });\n\n  const handleCheckedChange = useEventCallback((event: TreeCheckedChangeEvent, data: TreeCheckedChangeData) => {\n    const nextCheckedItems = createNextFlatCheckedItems(data, checkedItems, headlessTree);\n    options.onCheckedChange?.(event, {\n      ...data,\n      checkedItems: nextCheckedItems.dangerouslyGetInternalMap_unstable(),\n    });\n    setCheckedItems(nextCheckedItems);\n  });\n\n  const getNextNavigableItem = useEventCallback(\n    (visibleItems: HeadlessTreeItem<Props>[], data: TreeNavigationData_unstable) => {\n      const item = headlessTree.get(data.value);\n      if (item) {\n        switch (data.type) {\n          case treeDataTypes.TypeAhead:\n            return item;\n          case treeDataTypes.ArrowLeft:\n            return headlessTree.get(item.parentValue!);\n          case treeDataTypes.ArrowRight:\n            return visibleItems[item.index + 1];\n          case treeDataTypes.End:\n            return visibleItems[visibleItems.length - 1];\n          case treeDataTypes.Home:\n            return visibleItems[0];\n          case treeDataTypes.ArrowDown:\n            return visibleItems[item.index + 1];\n          case treeDataTypes.ArrowUp:\n            return visibleItems[item.index - 1];\n        }\n      }\n    },\n  );\n\n  const getElementFromItem = React.useCallback((item: HeadlessTreeItem<Props>) => {\n    return treeRef.current?.querySelector(`[${dataTreeItemValueAttrName}=\"${item.value}\"]`) as HTMLElement | null;\n  }, []);\n\n  const ref = useMergedRefs<HTMLDivElement>(treeRef, navigation.rootRef);\n\n  const getTreeProps = React.useCallback(\n    () => ({\n      ref,\n      openItems,\n      selectionMode: options.selectionMode,\n      checkedItems,\n      onOpenChange: handleOpenChange,\n      onCheckedChange: handleCheckedChange,\n      onNavigation: options.onNavigation ?? noop,\n    }),\n    // ref, handleOpenChange - useEventCallback, handleCheckedChange - useEventCallback\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    [openItems, checkedItems, options.selectionMode, options.onNavigation],\n  );\n\n  const items = React.useCallback(() => headlessTree.visibleItems(openItems), [openItems, headlessTree]);\n\n  const getItem = React.useCallback((value: TreeItemValue) => headlessTree.get(value), [headlessTree]);\n\n  return React.useMemo<HeadlessFlatTreeReturn<Props>>(\n    () => ({\n      navigate: navigation.navigate,\n      getTreeProps,\n      getNextNavigableItem,\n      getElementFromItem,\n      items,\n      getItem,\n    }),\n    [navigation.navigate, getTreeProps, getNextNavigableItem, getElementFromItem, items, getItem],\n  );\n}\n\n/** @internal */\nfunction noop() {\n  /* noop */\n}\n"],"names":["useHeadlessFlatTree_unstable","props","options","headlessTree","React","useMemo","createHeadlessTree","openItems","setOpenItems","useControllableOpenItems","checkedItems","setCheckedItems","useFlatControllableCheckedItems","navigation","useFlatTreeNavigation","treeRef","useRef","handleOpenChange","useEventCallback","event","data","nextOpenItems","createNextOpenItems","onOpenChange","dangerouslyGetInternalSet_unstable","handleCheckedChange","nextCheckedItems","createNextFlatCheckedItems","onCheckedChange","dangerouslyGetInternalMap_unstable","getNextNavigableItem","visibleItems","item","get","value","type","treeDataTypes","TypeAhead","ArrowLeft","parentValue","ArrowRight","index","End","length","Home","ArrowDown","ArrowUp","getElementFromItem","useCallback","current","querySelector","dataTreeItemValueAttrName","ref","useMergedRefs","rootRef","getTreeProps","selectionMode","onNavigation","noop","items","getItem","navigate"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib-commonjs/components/FlatTreeItem/FlatTreeItem.js.map

@@ -1 +1 @@
-{"version":3,"sources":["FlatTreeItem.js"],"sourcesContent":["import { TreeItem } from '../TreeItem/TreeItem';\n/**\n * The `FlatTreeItem` component represents a single item in a flat tree.\n */ export const FlatTreeItem = TreeItem;\n"],"names":["FlatTreeItem","TreeItem"],"mappings":";;;;+BAGiBA;;;eAAAA;;;0BAHQ;AAGd,MAAMA,eAAeC,kBAAQ"}
+{"version":3,"sources":["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":["FlatTreeItem","TreeItem"],"rangeMappings":";;;;;;;;;;;","mappings":";;;;+BAOaA;;;eAAAA;;;0BALY;AAKlB,MAAMA,eAAuDC,kBAAAA"}

package/lib-commonjs/components/FlatTreeItem/FlatTreeItem.types.js

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

package/lib-commonjs/components/FlatTreeItem/FlatTreeItem.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":""}
+{"version":3,"sources":["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":[],"rangeMappings":";;","mappings":"AAEA;;CAEC"}

package/lib-commonjs/components/FlatTreeItem/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './FlatTreeItem';\nexport * from './FlatTreeItem.types';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './FlatTreeItem';\nexport * from './FlatTreeItem.types';\n"],"names":[],"rangeMappings":";;;;;;","mappings":";;;;;uBAAc;uBACA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["Tree.js"],"sourcesContent":["import * as React from 'react';\nimport { useTree_unstable } from './useTree';\nimport { useTreeContextValues_unstable } from './useTreeContextValues';\nimport { useTreeStyles_unstable } from './useTreeStyles.styles';\nimport { renderTree_unstable } from './renderTree';\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 */ export const Tree = /*#__PURE__*/ React.forwardRef((props, ref)=>{\n    const state = useTree_unstable(props, ref);\n    const contextValues = useTreeContextValues_unstable(state);\n    useTreeStyles_unstable(state);\n    return renderTree_unstable(state, contextValues);\n});\nTree.displayName = 'Tree';\n"],"names":["Tree","React","forwardRef","props","ref","state","useTree_unstable","contextValues","useTreeContextValues_unstable","useTreeStyles_unstable","renderTree_unstable","displayName"],"mappings":";;;;+BAQiBA;;;eAAAA;;;;iEARM;yBACU;sCACa;qCACP;4BACH;AAIzB,MAAMA,OAAO,WAAW,GAAGC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC3D,MAAMC,QAAQC,IAAAA,yBAAgB,EAACH,OAAOC;IACtC,MAAMG,gBAAgBC,IAAAA,mDAA6B,EAACH;IACpDI,IAAAA,2CAAsB,EAACJ;IACvB,OAAOK,IAAAA,+BAAmB,EAACL,OAAOE;AACtC;AACAP,KAAKW,WAAW,GAAG"}
+{"version":3,"sources":["Tree.tsx"],"sourcesContent":["import * 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';\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  return renderTree_unstable(state, contextValues);\n});\n\nTree.displayName = 'Tree';\n"],"names":["Tree","React","forwardRef","props","ref","state","useTree_unstable","contextValues","useTreeContextValues_unstable","useTreeStyles_unstable","renderTree_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAYaA;;;eAAAA;;;;iEAZU;yBAEU;sCAEa;qCACP;4BACH;AAM7B,MAAMA,OAAAA,WAAAA,GAAuCC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC3E,MAAMC,QAAQC,IAAAA,yBAAAA,EAAiBH,OAAOC;IACtC,MAAMG,gBAAgBC,IAAAA,mDAAAA,EAA8BH;IACpDI,IAAAA,2CAAAA,EAAuBJ;IACvB,OAAOK,IAAAA,+BAAAA,EAAoBL,OAAOE;AACpC;AAEAP,KAAKW,WAAW,GAAG"}

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

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

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

@@ -1 +1 @@
-{"version":3,"sources":[],"names":[],"mappings":""}
+{"version":3,"sources":["Tree.types.ts"],"sourcesContent":["import type * as React from 'react';\nimport type { ComponentProps, ComponentState, SelectionMode, Slot } from '@fluentui/react-utilities';\nimport type { TreeContextValue, SubtreeContextValue } from '../../contexts';\nimport type { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Enter, Home } from '@fluentui/keyboard-keys';\nimport type { TreeItemValue } from '../TreeItem/TreeItem.types';\nimport { CheckboxProps } from '@fluentui/react-checkbox';\nimport { RadioProps } from '@fluentui/react-radio';\n\ntype MultiSelectValue = NonNullable<CheckboxProps['checked']>;\ntype SingleSelectValue = NonNullable<RadioProps['checked']>;\nexport type TreeSelectionValue = MultiSelectValue | SingleSelectValue;\n\nexport type TreeSlots = {\n  root: Slot<'div'>;\n};\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type TreeNavigationData_unstable = {\n  target: HTMLElement;\n  value: TreeItemValue;\n  parentValue: TreeItemValue | undefined;\n} & (\n  | { event: React.MouseEvent<HTMLElement>; type: 'Click' }\n  | { event: React.KeyboardEvent<HTMLElement>; type: 'TypeAhead' }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowRight }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowLeft }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowUp }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof ArrowDown }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof Home }\n  | { event: React.KeyboardEvent<HTMLElement>; type: typeof End }\n);\n\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport type TreeNavigationEvent_unstable = TreeNavigationData_unstable['event'];\n\nexport type TreeOpenChangeData = {\n  open: boolean;\n  openItems: Set<TreeItemValue>;\n  value: TreeItemValue;\n  target: HTMLElement;\n} & (\n  | { event: React.MouseEvent<HTMLElement>; type: 'ExpandIconClick' }\n  | { event: React.MouseEvent<HTMLElement>; type: 'Click' }\n  /**\n   * @deprecated\n   * Use `type: 'Click'` instead of Enter,\n   * an enter press will trigger a click event, which will trigger an open change,\n   * so there is no need to have a separate type for it.\n   */\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\n/**\n * @internal\n *\n * To avoid breaking changes on TreeNavigationData\n * we are creating a new type that extends the old one\n * and adds the new methods, and this type will not be exported\n */\ntype TreeNavigationDataParam = TreeNavigationData_unstable & {\n  preventScroll(): void;\n  isScrollPrevented(): boolean;\n};\n\nexport type TreeOpenChangeEvent = TreeOpenChangeData['event'];\n\nexport type TreeCheckedChangeData = {\n  value: TreeItemValue;\n  checkedItems: Map<TreeItemValue, TreeSelectionValue>;\n  target: HTMLElement;\n  event: React.ChangeEvent<HTMLElement>;\n  type: 'Change';\n} & (\n  | {\n      selectionMode: 'multiselect';\n      checked: MultiSelectValue;\n    }\n  | {\n      selectionMode: 'single';\n      checked: SingleSelectValue;\n    }\n);\n\nexport type TreeCheckedChangeEvent = TreeCheckedChangeData['event'];\n\nexport type TreeContextValues = {\n  tree: TreeContextValue | SubtreeContextValue;\n};\n\nexport type TreeProps = ComponentProps<TreeSlots> & {\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   * This refers to a list of ids of default opened items.\n   * This property is ignored for subtrees.\n   */\n  defaultOpenItems?: 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: TreeNavigationDataParam): 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\n/**\n * State used in rendering Tree\n */\nexport type TreeState = ComponentState<TreeSlots> & {\n  open: boolean;\n} & (TreeContextValue | SubtreeContextValue);\n"],"names":[],"rangeMappings":";;","mappings":"AAmKA;;CAEC"}

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

@@ -1 +1 @@
-{"version":3,"sources":["index.js"],"sourcesContent":["export * from './Tree';\nexport * from './Tree.types';\nexport * from './useTree';\nexport * from './useTreeContextValues';\nexport * from './useTreeStyles.styles';\nexport * from './renderTree';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA"}
+{"version":3,"sources":["index.ts"],"sourcesContent":["export * from './Tree';\nexport * from './Tree.types';\nexport * from './useTree';\nexport * from './useTreeContextValues';\nexport * from './useTreeStyles.styles';\nexport * from './renderTree';\n"],"names":[],"rangeMappings":";;;;;;;;;;","mappings":";;;;;uBAAc;uBACA;uBACA;uBACA;uBACA;uBACA"}

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

@@ -1 +1 @@
-{"version":3,"sources":["renderTree.js"],"sourcesContent":["  import { jsx as _jsx } from \"@fluentui/react-jsx-runtime/jsx-runtime\";\nimport { assertSlots } from '@fluentui/react-utilities';\nimport { TreeProvider } from '../TreeProvider';\nexport const renderTree_unstable = (state, contextValues)=>{\n    assertSlots(state);\n    return /*#__PURE__*/ _jsx(TreeProvider, {\n        value: contextValues.tree,\n        children: state.open && /*#__PURE__*/ _jsx(state.root, {\n            children: state.root.children\n        })\n    });\n};\n"],"names":["renderTree_unstable","state","contextValues","assertSlots","_jsx","TreeProvider","value","tree","children","open","root"],"mappings":";;;;+BAGaA;;;eAAAA;;;4BAHiB;gCACF;8BACC;AACtB,MAAMA,sBAAsB,CAACC,OAAOC;IACvCC,IAAAA,2BAAW,EAACF;IACZ,OAAO,WAAW,GAAGG,IAAAA,eAAI,EAACC,0BAAY,EAAE;QACpCC,OAAOJ,cAAcK,IAAI;QACzBC,UAAUP,MAAMQ,IAAI,IAAI,WAAW,GAAGL,IAAAA,eAAI,EAACH,MAAMS,IAAI,EAAE;YACnDF,UAAUP,MAAMS,IAAI,CAACF,QAAQ;QACjC;IACJ;AACJ"}
+{"version":3,"sources":["renderTree.tsx"],"sourcesContent":["/** @jsxRuntime automatic */\n/** @jsxImportSource @fluentui/react-jsx-runtime */\nimport { assertSlots } 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) => {\n  assertSlots<TreeSlots>(state);\n  return (\n    <TreeProvider value={contextValues.tree}>\n      {state.open && <state.root>{state.root.children}</state.root>}\n    </TreeProvider>\n  );\n};\n"],"names":["renderTree_unstable","state","contextValues","assertSlots","_jsx","TreeProvider","value","tree","open","root","children"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAMaA;;;eAAAA;;;4BALb;gCAC4B;8BAEC;AAEtB,MAAMA,sBAAsB,CAACC,OAAkBC;IACpDC,IAAAA,2BAAAA,EAAuBF;IACvB,OAAA,WAAA,GACEG,IAAAA,eAAA,EAACC,0BAAAA,EAAAA;QAAaC,OAAOJ,cAAcK,IAAI;kBACpCN,MAAMO,IAAI,IAAA,WAAA,GAAIJ,IAAAA,eAAA,EAACH,MAAMQ,IAAI,EAAA;sBAAER,MAAMQ,IAAI,CAACC,QAAQ;;;AAGrD"}

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

@@ -9,11 +9,11 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    useNestedCheckedItems: function() {
-        return useNestedCheckedItems;
-    },
     createNextNestedCheckedItems: function() {
         return createNextNestedCheckedItems;
+    },
+    useNestedCheckedItems: function() {
+        return useNestedCheckedItems;
     }
 });
 const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");

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

@@ -1 +1 @@
-{"version":3,"sources":["useNestedControllableCheckedItems.js"],"sourcesContent":["import * as React from 'react';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nexport function useNestedCheckedItems(props) {\n    return React.useMemo(()=>createCheckedItems(props.checkedItems), [\n        props.checkedItems\n    ]);\n}\nexport function createNextNestedCheckedItems(data, previousCheckedItems) {\n    if (data.selectionMode === 'single') {\n        return ImmutableMap.create([\n            [\n                data.value,\n                data.checked\n            ]\n        ]);\n    }\n    if (data.selectionMode === 'multiselect') {\n        return previousCheckedItems.set(data.value, data.checked);\n    }\n    return previousCheckedItems;\n}\n"],"names":["useNestedCheckedItems","createNextNestedCheckedItems","props","React","useMemo","createCheckedItems","checkedItems","data","previousCheckedItems","selectionMode","ImmutableMap","create","value","checked","set"],"mappings":";;;;;;;;;;;IAGgBA,qBAAqB;eAArBA;;IAKAC,4BAA4B;eAA5BA;;;;iEARO;8BACM;oCACM;AAC5B,SAASD,sBAAsBE,KAAK;IACvC,OAAOC,OAAMC,OAAO,CAAC,IAAIC,IAAAA,sCAAkB,EAACH,MAAMI,YAAY,GAAG;QAC7DJ,MAAMI,YAAY;KACrB;AACL;AACO,SAASL,6BAA6BM,IAAI,EAAEC,oBAAoB;IACnE,IAAID,KAAKE,aAAa,KAAK,UAAU;QACjC,OAAOC,0BAAY,CAACC,MAAM,CAAC;YACvB;gBACIJ,KAAKK,KAAK;gBACVL,KAAKM,OAAO;aACf;SACJ;IACL;IACA,IAAIN,KAAKE,aAAa,KAAK,eAAe;QACtC,OAAOD,qBAAqBM,GAAG,CAACP,KAAKK,KAAK,EAAEL,KAAKM,OAAO;IAC5D;IACA,OAAOL;AACX"}
+{"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"}

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

@@ -19,6 +19,7 @@ const _useSubtree = require("../../hooks/useSubtree");
 const _useTreeNavigation = require("../../hooks/useTreeNavigation");
 const _treeContext = require("../../contexts/treeContext");
 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
@@ -26,6 +27,7 @@ const useTree_unstable = (props, ref)=>{
     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)();
@@ -64,6 +66,7 @@ function useNestedRootTree(props, ref) {
     });
 }
 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

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

@@ -1 +1 @@
-{"version":3,"sources":["useTree.js"],"sourcesContent":["import * as React from 'react';\nimport { useEventCallback, useMergedRefs } from '@fluentui/react-utilities';\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';\nexport const useTree_unstable = (props, ref)=>{\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};\nfunction useNestedRootTree(props, ref) {\n    const [openItems, setOpenItems] = useControllableOpenItems(props);\n    const checkedItems = useNestedCheckedItems(props);\n    const navigation = useTreeNavigation();\n    return Object.assign(useRootTree({\n        ...props,\n        openItems,\n        checkedItems,\n        onOpenChange: useEventCallback((event, data)=>{\n            var _props_onOpenChange;\n            const nextOpenItems = createNextOpenItems(data, openItems);\n            (_props_onOpenChange = props.onOpenChange) === null || _props_onOpenChange === void 0 ? void 0 : _props_onOpenChange.call(props, event, {\n                ...data,\n                openItems: nextOpenItems.dangerouslyGetInternalSet_unstable()\n            });\n            setOpenItems(nextOpenItems);\n        }),\n        onNavigation: useEventCallback((event, data)=>{\n            var _props_onNavigation;\n            (_props_onNavigation = props.onNavigation) === null || _props_onNavigation === void 0 ? void 0 : _props_onNavigation.call(props, event, data);\n            if (!event.isDefaultPrevented()) {\n                navigation.navigate(data, {\n                    preventScroll: data.isScrollPrevented()\n                });\n            }\n        }),\n        onCheckedChange: useEventCallback((event, data)=>{\n            var _props_onCheckedChange;\n            const nextCheckedItems = createNextNestedCheckedItems(data, checkedItems);\n            (_props_onCheckedChange = props.onCheckedChange) === null || _props_onCheckedChange === void 0 ? void 0 : _props_onCheckedChange.call(props, event, {\n                ...data,\n                checkedItems: nextCheckedItems.dangerouslyGetInternalMap_unstable()\n            });\n        })\n    }, useMergedRefs(ref, navigation.treeRef)), {\n        treeType: 'nested'\n    });\n}\nfunction useNestedSubtree(props, ref) {\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(`@fluentui/react-tree [useTree]:\nSubtrees are not allowed in a FlatTree!\nYou cannot use a <Tree> component inside of a <FlatTree> component!`);\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","_props_onOpenChange","nextOpenItems","createNextOpenItems","call","dangerouslyGetInternalSet_unstable","onNavigation","_props_onNavigation","isDefaultPrevented","navigate","preventScroll","isScrollPrevented","onCheckedChange","_props_onCheckedChange","nextCheckedItems","createNextNestedCheckedItems","dangerouslyGetInternalMap_unstable","useMergedRefs","treeRef","treeType","process","env","NODE_ENV","useTreeContext_unstable","ctx","Error","useSubtree"],"mappings":";;;;+BASaA;;;eAAAA;;;;iEATU;gCACyB;0CACc;mDACM;gCACrC;6BACH;4BACD;mCACO;6BACM;AACjC,MAAMA,mBAAmB,CAACC,OAAOC;IACpC,MAAMC,SAASC,OAAMC,UAAU,CAACC,8BAAc,MAAMC;IACpD,uDAAuD;IACvD,sEAAsE;IACtE,sDAAsD;IACtD,OAAOJ,SAASK,kBAAkBP,OAAOC,OAAOO,iBAAiBR,OAAOC;AAC5E;AACA,SAASM,kBAAkBP,KAAK,EAAEC,GAAG;IACjC,MAAM,CAACQ,WAAWC,aAAa,GAAGC,IAAAA,kDAAwB,EAACX;IAC3D,MAAMY,eAAeC,IAAAA,wDAAqB,EAACb;IAC3C,MAAMc,aAAaC,IAAAA,oCAAiB;IACpC,OAAOC,OAAOC,MAAM,CAACC,IAAAA,wBAAW,EAAC;QAC7B,GAAGlB,KAAK;QACRS;QACAG;QACAO,cAAcC,IAAAA,gCAAgB,EAAC,CAACC,OAAOC;YACnC,IAAIC;YACJ,MAAMC,gBAAgBC,IAAAA,6CAAmB,EAACH,MAAMb;YAC/Cc,CAAAA,sBAAsBvB,MAAMmB,YAAY,AAAD,MAAO,QAAQI,wBAAwB,KAAK,IAAI,KAAK,IAAIA,oBAAoBG,IAAI,CAAC1B,OAAOqB,OAAO;gBACpI,GAAGC,IAAI;gBACPb,WAAWe,cAAcG,kCAAkC;YAC/D;YACAjB,aAAac;QACjB;QACAI,cAAcR,IAAAA,gCAAgB,EAAC,CAACC,OAAOC;YACnC,IAAIO;YACHA,CAAAA,sBAAsB7B,MAAM4B,YAAY,AAAD,MAAO,QAAQC,wBAAwB,KAAK,IAAI,KAAK,IAAIA,oBAAoBH,IAAI,CAAC1B,OAAOqB,OAAOC;YACxI,IAAI,CAACD,MAAMS,kBAAkB,IAAI;gBAC7BhB,WAAWiB,QAAQ,CAACT,MAAM;oBACtBU,eAAeV,KAAKW,iBAAiB;gBACzC;YACJ;QACJ;QACAC,iBAAiBd,IAAAA,gCAAgB,EAAC,CAACC,OAAOC;YACtC,IAAIa;YACJ,MAAMC,mBAAmBC,IAAAA,+DAA4B,EAACf,MAAMV;YAC3DuB,CAAAA,yBAAyBnC,MAAMkC,eAAe,AAAD,MAAO,QAAQC,2BAA2B,KAAK,IAAI,KAAK,IAAIA,uBAAuBT,IAAI,CAAC1B,OAAOqB,OAAO;gBAChJ,GAAGC,IAAI;gBACPV,cAAcwB,iBAAiBE,kCAAkC;YACrE;QACJ;IACJ,GAAGC,IAAAA,6BAAa,EAACtC,KAAKa,WAAW0B,OAAO,IAAI;QACxCC,UAAU;IACd;AACJ;AACA,SAASjC,iBAAiBR,KAAK,EAAEC,GAAG;IAChC,IAAIyC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QACxC,qEAAqE;QACrE,sDAAsD;QACtD,MAAMH,WAAWI,IAAAA,oCAAuB,EAAC,CAACC,MAAMA,IAAIL,QAAQ;QAC5D,IAAIA,aAAa,QAAQ;YACrB,MAAM,IAAIM,MAAM,CAAC;;mEAEsC,CAAC;QAC5D;IACJ;IACA,OAAOC,IAAAA,sBAAU,EAAChD,OAAOC;AAC7B"}
+{"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"}

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

@@ -11,6 +11,7 @@ Object.defineProperty(exports, "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, appearance, size, requestTreeResponse } = state;
         /**

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

@@ -1 +1 @@
-{"version":3,"sources":["useTreeContextValues.js"],"sourcesContent":["import * as React from 'react';\nexport function useTreeContextValues_unstable(state) {\n    if (state.contextType === 'root') {\n        const { openItems, level, contextType, treeType, checkedItems, selectionMode, appearance, size, requestTreeResponse } = state;\n        /**\n     * This context is created with \"@fluentui/react-context-selector\",\n     * there is no sense to memoize it\n     */ const tree = {\n            treeType,\n            size,\n            openItems,\n            appearance,\n            checkedItems,\n            selectionMode,\n            contextType,\n            level,\n            requestTreeResponse\n        };\n        return {\n            tree\n        };\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(()=>({\n                level: state.level,\n                contextType: 'subtree'\n            }), [\n            state.level\n        ])\n    };\n}\n"],"names":["useTreeContextValues_unstable","state","contextType","openItems","level","treeType","checkedItems","selectionMode","appearance","size","requestTreeResponse","tree","React","useMemo"],"mappings":";;;;+BACgBA;;;eAAAA;;;;iEADO;AAChB,SAASA,8BAA8BC,KAAK;IAC/C,IAAIA,MAAMC,WAAW,KAAK,QAAQ;QAC9B,MAAM,EAAEC,SAAS,EAAEC,KAAK,EAAEF,WAAW,EAAEG,QAAQ,EAAEC,YAAY,EAAEC,aAAa,EAAEC,UAAU,EAAEC,IAAI,EAAEC,mBAAmB,EAAE,GAAGT;QACxH;;;KAGH,GAAG,MAAMU,OAAO;YACTN;YACAI;YACAN;YACAK;YACAF;YACAC;YACAL;YACAE;YACAM;QACJ;QACA,OAAO;YACHC;QACJ;IACJ;IACA,OAAO;QACH,sDAAsD;QACtD,sDAAsD;QACtDA,MAAMC,OAAMC,OAAO,CAAC,IAAK,CAAA;gBACjBT,OAAOH,MAAMG,KAAK;gBAClBF,aAAa;YACjB,CAAA,GAAI;YACJD,MAAMG,KAAK;SACd;IACL;AACJ"}
+{"version":3,"sources":["useTreeContextValues.ts"],"sourcesContent":["import * 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      appearance,\n      size,\n      requestTreeResponse,\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      contextType,\n      level,\n      requestTreeResponse,\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":["useTreeContextValues_unstable","state","contextType","openItems","level","treeType","checkedItems","selectionMode","appearance","size","requestTreeResponse","tree","React","useMemo"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;;iEAJO;AAIhB,SAASA,8BAA8BC,KAAgB;IAC5D;IAEA,IAAIA,MAAMC,WAAW,KAAK,QAAQ;QAChC,MAAM,EACJC,SAAS,EACTC,KAAK,EACLF,WAAW,EACXG,QAAQ,EACRC,YAAY,EACZC,aAAa,EACbC,UAAU,EACVC,IAAI,EACJC,mBAAmB,EACpB,GAAGT;QACJ;;;KAGC,GACD,MAAMU,OAAyB;YAC7BN;YACAI;YACAN;YACAK;YACAF;YACAC;YACAL;YACAE;YACAM;QACF;QAEA,OAAO;YAAEC;QAAK;IAChB;IACA,OAAO;QACL,sDAAsD;QACtD,sDAAsD;QACtDA,MAAMC,OAAMC,OAAO,CAAC,IAAO,CAAA;gBAAET,OAAOH,MAAMG,KAAK;gBAAEF,aAAa;YAAU,CAAA,GAAI;YAACD,MAAMG,KAAK;SAAC;IAC3F;AACF"}

package/lib-commonjs/components/Tree/useTreeStyles.styles.js

@@ -33,6 +33,7 @@ const useStyles = /*#__PURE__*/ (0, _react.__styles)({
     ]
 });
 const useTreeStyles_unstable = (state)=>{
+    'use no memo';
     const baseStyles = useBaseStyles();
     const styles = useStyles();
     const isSubTree = state.level > 1;

package/lib-commonjs/components/Tree/useTreeStyles.styles.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useTreeStyles.styles.js"],"sourcesContent":["import { __resetStyles, __styles, mergeClasses } from '@griffel/react';\nimport { tokens } from '@fluentui/react-theme';\nexport const treeClassNames = {\n  root: 'fui-Tree'\n};\nconst useBaseStyles = /*#__PURE__*/__resetStyles(\"rnv2ez3\", null, [\".rnv2ez3{display:flex;flex-direction:column;row-gap:var(--spacingVerticalXXS);}\"]);\nconst useStyles = /*#__PURE__*/__styles({\n  subtree: {\n    z8tnut: \"fclwglc\"\n  }\n}, {\n  d: [\".fclwglc{padding-top:var(--spacingVerticalXXS);}\"]\n});\nexport const useTreeStyles_unstable = state => {\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//# sourceMappingURL=useTreeStyles.styles.js.map"],"names":["treeClassNames","useTreeStyles_unstable","root","useBaseStyles","__resetStyles","useStyles","__styles","subtree","z8tnut","d","state","baseStyles","styles","isSubTree","level","className","mergeClasses"],"mappings":";;;;;;;;;;;IAEaA,cAAc;eAAdA;;IAWAC,sBAAsB;eAAtBA;;;uBAbyC;AAE/C,MAAMD,iBAAiB;IAC5BE,MAAM;AACR;AACA,MAAMC,gBAAgB,WAAW,GAAEC,IAAAA,oBAAa,EAAC,WAAW,MAAM;IAAC;CAAkF;AACrJ,MAAMC,YAAY,WAAW,GAAEC,IAAAA,eAAQ,EAAC;IACtCC,SAAS;QACPC,QAAQ;IACV;AACF,GAAG;IACDC,GAAG;QAAC;KAAmD;AACzD;AACO,MAAMR,yBAAyBS,CAAAA;IACpC,MAAMC,aAAaR;IACnB,MAAMS,SAASP;IACf,MAAMQ,YAAYH,MAAMI,KAAK,GAAG;IAChCJ,MAAMR,IAAI,CAACa,SAAS,GAAGC,IAAAA,mBAAY,EAAChB,eAAeE,IAAI,EAAES,YAAYE,aAAaD,OAAOL,OAAO,EAAEG,MAAMR,IAAI,CAACa,SAAS;IACtH,OAAOL;AACT,GACA,gDAAgD"}
+{"version":3,"sources":["useTreeStyles.styles.js"],"sourcesContent":["import { 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":["treeClassNames","useTreeStyles_unstable","root","useBaseStyles","__resetStyles","useStyles","__styles","subtree","z8tnut","d","state","baseStyles","styles","isSubTree","level","className","mergeClasses"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAEaA,cAAc;eAAdA;;IAaAC,sBAAsB;eAAtBA;;;uBAf6C;AAEnD,MAAMD,iBAAiB;IAC1BE,MAAM;AACV;AACA,MAAMC,gBAAa,WAAA,GAAGC,IAAAA,oBAAA,EAAA,WAAA,MAAA;IAAA;CAIrB;AACD,MAAMC,YAAS,WAAA,GAAGC,IAAAA,eAAA,EAAA;IAAAC,SAAA;QAAAC,QAAA;IAAA;AAAA,GAAA;IAAAC,GAAA;QAAA;KAAA;AAAA;AAKX,MAAMR,yBAA0BS,CAAAA;IACnC;IACA,MAAMC,aAAaR;IACnB,MAAMS,SAASP;IACf,MAAMQ,YAAYH,MAAMI,KAAK,GAAG;IAChCJ,MAAMR,IAAI,CAACa,SAAS,GAAGC,IAAAA,mBAAY,EAAChB,eAAeE,IAAI,EAAES,YAAYE,aAAaD,OAAOL,OAAO,EAAEG,MAAMR,IAAI,CAACa,SAAS;IACtH,OAAOL;AACX"}

package/lib-commonjs/components/TreeItem/TreeItem.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TreeItem.js"],"sourcesContent":["import * as React from 'react';\nimport { useTreeItem_unstable } from './useTreeItem';\nimport { renderTreeItem_unstable } from './renderTreeItem';\nimport { useTreeItemStyles_unstable } from './useTreeItemStyles.styles';\nimport { useTreeItemContextValues_unstable } from './useTreeItemContextValues';\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 */ export const TreeItem = /*#__PURE__*/ React.forwardRef((props, ref)=>{\n    const state = useTreeItem_unstable(props, ref);\n    useTreeItemStyles_unstable(state);\n    const contextValues = useTreeItemContextValues_unstable(state);\n    return renderTreeItem_unstable(state, contextValues);\n});\nTreeItem.displayName = 'TreeItem';\n"],"names":["TreeItem","React","forwardRef","props","ref","state","useTreeItem_unstable","useTreeItemStyles_unstable","contextValues","useTreeItemContextValues_unstable","renderTreeItem_unstable","displayName"],"mappings":";;;;+BAgBiBA;;;eAAAA;;;;iEAhBM;6BACc;gCACG;yCACG;0CACO;AAYvC,MAAMA,WAAW,WAAW,GAAGC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IAC/D,MAAMC,QAAQC,IAAAA,iCAAoB,EAACH,OAAOC;IAC1CG,IAAAA,mDAA0B,EAACF;IAC3B,MAAMG,gBAAgBC,IAAAA,2DAAiC,EAACJ;IACxD,OAAOK,IAAAA,uCAAuB,EAACL,OAAOG;AAC1C;AACAR,SAASW,WAAW,GAAG"}
+{"version":3,"sources":["TreeItem.tsx"],"sourcesContent":["import * 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';\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  const contextValues = useTreeItemContextValues_unstable(state);\n  return renderTreeItem_unstable(state, contextValues);\n});\n\nTreeItem.displayName = 'TreeItem';\n"],"names":["TreeItem","React","forwardRef","props","ref","state","useTreeItem_unstable","useTreeItemStyles_unstable","contextValues","useTreeItemContextValues_unstable","renderTreeItem_unstable","displayName"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAoBaA;;;eAAAA;;;;iEApBU;6BACc;gCACG;yCACG;0CAGO;AAc3C,MAAMA,WAAAA,WAAAA,GAA+CC,OAAMC,UAAU,CAAC,CAACC,OAAOC;IACnF,MAAMC,QAAQC,IAAAA,iCAAAA,EAAqBH,OAAOC;IAE1CG,IAAAA,mDAAAA,EAA2BF;IAC3B,MAAMG,gBAAgBC,IAAAA,2DAAAA,EAAkCJ;IACxD,OAAOK,IAAAA,uCAAAA,EAAwBL,OAAOG;AACxC;AAEAR,SAASW,WAAW,GAAG"}

package/lib-commonjs/components/TreeItem/TreeItem.types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["TreeItem.types.js"],"sourcesContent":["import * as React from 'react';\n"],"names":[],"mappings":";;;;;iEAAuB"}
+{"version":3,"sources":["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":[],"rangeMappings":";;;;;","mappings":";;;;;iEAAuB"}