npm - @fluentui/react-tree - Versions diffs - 9.7.2 → 9.7.3 - Mend

@fluentui/react-tree 9.7.2 → 9.7.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (158) hide show

package/lib/utils/assert.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["assert.ts"],"sourcesContent":["import * as React from 'react';\n\nexport function assertIsDefinedRef<V>(\n refObject: React.RefObject<V \| null \| undefined>,\n msg = `assertIsDefinedRef: reference not properly defined ${refObject}`,\n): asserts refObject is React.MutableRefObject<V> {\n // eslint-disable-next-line eqeqeq\n if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n throw new TypeError(msg);\n }\n}\n"],"names":["React","assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,OAAO,SAASC,mBACdC,SAAgD,EAChDC,MAAM,CAAC,mDAAmD,EAAED,UAAU,CAAC;IAEvE,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC5E,MAAM,IAAIC,UAAUN;IACtB;AACF"}
1	+ {"version":3,"sources":["assert.ts"],"sourcesContent":["import * as React from 'react';\n\nexport function assertIsDefinedRef<V>(\n refObject: React.RefObject<V \| null \| undefined>,\n msg = `assertIsDefinedRef: reference not properly defined ${refObject}`,\n): asserts refObject is React.MutableRefObject<V> {\n // eslint-disable-next-line eqeqeq\n if (refObject.current == undefined && process.env.NODE_ENV === 'development') {\n throw new TypeError(msg);\n }\n}\n"],"names":["React","assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"rangeMappings":";;;;;;","mappings":"AAAA,YAAYA,WAAW,QAAQ;AAE/B,OAAO,SAASC,mBACdC,SAAgD,EAChDC,MAAM,CAAC,mDAAmD,EAAED,UAAU,CAAC;IAEvE,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC5E,MAAM,IAAIC,UAAUN;IACtB;AACF"}

package/lib/utils/createCheckedItems.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["createCheckedItems.ts"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nimport type { TreeSelectionValue } from '../Tree';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createCheckedItems(iterable?: Iterable<TreeItemValue \| [TreeItemValue, TreeSelectionValue]>) {\n if (iterable === undefined) {\n return ImmutableMap.empty;\n }\n if (ImmutableMap.isImmutableMap<TreeItemValue, TreeSelectionValue>(iterable)) {\n return iterable;\n }\n const internalMap = new Map<TreeItemValue, 'mixed' \| boolean>();\n for (const item of iterable) {\n if (Array.isArray(item)) {\n internalMap.set(item[0], item[1]);\n } else {\n internalMap.set(item, true);\n }\n }\n return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["ImmutableMap","createCheckedItems","iterable","undefined","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAI9C,OAAO,SAASC,mBAAmBC,QAAwE;IACzG,IAAIA,aAAaC,WAAW;QAC1B,OAAOH,aAAaI,KAAK;IAC3B;IACA,IAAIJ,aAAaK,cAAc,CAAoCH,WAAW;QAC5E,OAAOA;IACT;IACA,MAAMI,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQN,SAAU;QAC3B,IAAIO,MAAMC,OAAO,CAACF,OAAO;YACvBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QAClC,OAAO;YACLF,YAAYK,GAAG,CAACH,MAAM;QACxB;IACF;IACA,OAAOR,aAAaY,0BAA0B,CAACN;AACjD"}
1	+ {"version":3,"sources":["createCheckedItems.ts"],"sourcesContent":["import { ImmutableMap } from './ImmutableMap';\nimport type { TreeSelectionValue } from '../Tree';\nimport type { TreeItemValue } from '../TreeItem';\n\nexport function createCheckedItems(iterable?: Iterable<TreeItemValue \| [TreeItemValue, TreeSelectionValue]>) {\n if (iterable === undefined) {\n return ImmutableMap.empty;\n }\n if (ImmutableMap.isImmutableMap<TreeItemValue, TreeSelectionValue>(iterable)) {\n return iterable;\n }\n const internalMap = new Map<TreeItemValue, 'mixed' \| boolean>();\n for (const item of iterable) {\n if (Array.isArray(item)) {\n internalMap.set(item[0], item[1]);\n } else {\n internalMap.set(item, true);\n }\n }\n return ImmutableMap.dangerouslyCreate_unstable(internalMap);\n}\n"],"names":["ImmutableMap","createCheckedItems","iterable","undefined","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,YAAY,QAAQ,iBAAiB;AAI9C,OAAO,SAASC,mBAAmBC,QAAwE;IACzG,IAAIA,aAAaC,WAAW;QAC1B,OAAOH,aAAaI,KAAK;IAC3B;IACA,IAAIJ,aAAaK,cAAc,CAAoCH,WAAW;QAC5E,OAAOA;IACT;IACA,MAAMI,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQN,SAAU;QAC3B,IAAIO,MAAMC,OAAO,CAACF,OAAO;YACvBF,YAAYK,GAAG,CAACH,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QAClC,OAAO;YACLF,YAAYK,GAAG,CAACH,MAAM;QACxB;IACF;IACA,OAAOR,aAAaY,0BAA0B,CAACN;AACjD"}

package/lib/utils/createHTMLElementWalker.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["createHTMLElementWalker.ts"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\n\nexport interface HTMLElementWalker {\n readonly root: HTMLElement;\n currentElement: HTMLElement;\n firstChild(filter?: HTMLElementFilter): HTMLElement \| null;\n lastChild(filter?: HTMLElementFilter): HTMLElement \| null;\n nextElement(filter?: HTMLElementFilter): HTMLElement \| null;\n nextSibling(filter?: HTMLElementFilter): HTMLElement \| null;\n parentElement(filter?: HTMLElementFilter): HTMLElement \| null;\n previousElement(filter?: HTMLElementFilter): HTMLElement \| null;\n previousSibling(filter?: HTMLElementFilter): HTMLElement \| null;\n}\n\nexport type HTMLElementFilter = (element: HTMLElement) => number;\n\nexport function createHTMLElementWalker(\n root: HTMLElement,\n targetDocument: Document,\n filter: HTMLElementFilter = () => NodeFilter.FILTER_ACCEPT,\n): HTMLElementWalker {\n let temporaryFilter: HTMLElementFilter \| undefined;\n const treeWalker = targetDocument.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n acceptNode(node: Node) {\n if (!isHTMLElement(node)) {\n return NodeFilter.FILTER_REJECT;\n }\n const filterResult = filter(node);\n return filterResult === NodeFilter.FILTER_ACCEPT ? temporaryFilter?.(node) ?? filterResult : filterResult;\n },\n });\n return {\n get root() {\n return treeWalker.root as HTMLElement;\n },\n get currentElement() {\n return treeWalker.currentNode as HTMLElement;\n },\n set currentElement(element) {\n treeWalker.currentNode = element;\n },\n firstChild: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.firstChild() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n lastChild: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.lastChild() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n nextElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.nextNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n nextSibling: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.nextSibling() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n parentElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.parentNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n previousElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.previousNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n previousSibling: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.previousSibling() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n };\n}\n"],"names":["isHTMLElement","createHTMLElementWalker","root","targetDocument","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","createTreeWalker","SHOW_ELEMENT","acceptNode","node","FILTER_REJECT","filterResult","currentElement","currentNode","element","firstChild","localFilter","result","undefined","lastChild","nextElement","nextNode","nextSibling","parentElement","parentNode","previousElement","previousNode","previousSibling"],"mappings":"AAAA,SAASA,aAAa,QAAQ,4BAA4B;AAgB1D,OAAO,SAASC,wBACdC,IAAiB,EACjBC,cAAwB,EACxBC,SAA4B,IAAMC,WAAWC,aAAa;IAE1D,IAAIC;IACJ,MAAMC,aAAaL,eAAeM,gBAAgB,CAACP,MAAMG,WAAWK,YAAY,EAAE;QAChFC,YAAWC,IAAU;YACnB,IAAI,CAACZ,cAAcY,OAAO;gBACxB,OAAOP,WAAWQ,aAAa;YACjC;YACA,MAAMC,eAAeV,OAAOQ;gBACuBL;YAAnD,OAAOO,iBAAiBT,WAAWC,aAAa,GAAGC,CAAAA,mBAAAA,4BAAAA,sCAAAA,gBAAkBK,mBAAlBL,8BAAAA,mBAA2BO,eAAeA;QAC/F;IACF;IACA,OAAO;QACL,IAAIZ,QAAO;YACT,OAAOM,WAAWN,IAAI;QACxB;QACA,IAAIa,kBAAiB;YACnB,OAAOP,WAAWQ,WAAW;QAC/B;QACA,IAAID,gBAAeE,QAAS;YAC1BT,WAAWQ,WAAW,GAAGC;QAC3B;QACAC,YAAYC,CAAAA;YACVZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWU,UAAU;YACpCX,kBAAkBc;YAClB,OAAOD;QACT;QACAE,WAAWH,CAAAA;YACTZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWc,SAAS;YACnCf,kBAAkBc;YAClB,OAAOD;QACT;QACAG,aAAaJ,CAAAA;YACXZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWgB,QAAQ;YAClCjB,kBAAkBc;YAClB,OAAOD;QACT;QACAK,aAAaN,CAAAA;YACXZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWiB,WAAW;YACrClB,kBAAkBc;YAClB,OAAOD;QACT;QACAM,eAAeP,CAAAA;YACbZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWmB,UAAU;YACpCpB,kBAAkBc;YAClB,OAAOD;QACT;QACAQ,iBAAiBT,CAAAA;YACfZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWqB,YAAY;YACtCtB,kBAAkBc;YAClB,OAAOD;QACT;QACAU,iBAAiBX,CAAAA;YACfZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWsB,eAAe;YACzCvB,kBAAkBc;YAClB,OAAOD;QACT;IACF;AACF"}
1	+ {"version":3,"sources":["createHTMLElementWalker.ts"],"sourcesContent":["import { isHTMLElement } from '@fluentui/react-utilities';\n\nexport interface HTMLElementWalker {\n readonly root: HTMLElement;\n currentElement: HTMLElement;\n firstChild(filter?: HTMLElementFilter): HTMLElement \| null;\n lastChild(filter?: HTMLElementFilter): HTMLElement \| null;\n nextElement(filter?: HTMLElementFilter): HTMLElement \| null;\n nextSibling(filter?: HTMLElementFilter): HTMLElement \| null;\n parentElement(filter?: HTMLElementFilter): HTMLElement \| null;\n previousElement(filter?: HTMLElementFilter): HTMLElement \| null;\n previousSibling(filter?: HTMLElementFilter): HTMLElement \| null;\n}\n\nexport type HTMLElementFilter = (element: HTMLElement) => number;\n\nexport function createHTMLElementWalker(\n root: HTMLElement,\n targetDocument: Document,\n filter: HTMLElementFilter = () => NodeFilter.FILTER_ACCEPT,\n): HTMLElementWalker {\n let temporaryFilter: HTMLElementFilter \| undefined;\n const treeWalker = targetDocument.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {\n acceptNode(node: Node) {\n if (!isHTMLElement(node)) {\n return NodeFilter.FILTER_REJECT;\n }\n const filterResult = filter(node);\n return filterResult === NodeFilter.FILTER_ACCEPT ? temporaryFilter?.(node) ?? filterResult : filterResult;\n },\n });\n return {\n get root() {\n return treeWalker.root as HTMLElement;\n },\n get currentElement() {\n return treeWalker.currentNode as HTMLElement;\n },\n set currentElement(element) {\n treeWalker.currentNode = element;\n },\n firstChild: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.firstChild() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n lastChild: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.lastChild() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n nextElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.nextNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n nextSibling: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.nextSibling() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n parentElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.parentNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n previousElement: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.previousNode() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n previousSibling: localFilter => {\n temporaryFilter = localFilter;\n const result = treeWalker.previousSibling() as HTMLElement \| null;\n temporaryFilter = undefined;\n return result;\n },\n };\n}\n"],"names":["isHTMLElement","createHTMLElementWalker","root","targetDocument","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","createTreeWalker","SHOW_ELEMENT","acceptNode","node","FILTER_REJECT","filterResult","currentElement","currentNode","element","firstChild","localFilter","result","undefined","lastChild","nextElement","nextNode","nextSibling","parentElement","parentNode","previousElement","previousNode","previousSibling"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,SAASA,aAAa,QAAQ,4BAA4B;AAgB1D,OAAO,SAASC,wBACdC,IAAiB,EACjBC,cAAwB,EACxBC,SAA4B,IAAMC,WAAWC,aAAa;IAE1D,IAAIC;IACJ,MAAMC,aAAaL,eAAeM,gBAAgB,CAACP,MAAMG,WAAWK,YAAY,EAAE;QAChFC,YAAWC,IAAU;YACnB,IAAI,CAACZ,cAAcY,OAAO;gBACxB,OAAOP,WAAWQ,aAAa;YACjC;YACA,MAAMC,eAAeV,OAAOQ;gBACuBL;YAAnD,OAAOO,iBAAiBT,WAAWC,aAAa,GAAGC,CAAAA,mBAAAA,4BAAAA,sCAAAA,gBAAkBK,mBAAlBL,8BAAAA,mBAA2BO,eAAeA;QAC/F;IACF;IACA,OAAO;QACL,IAAIZ,QAAO;YACT,OAAOM,WAAWN,IAAI;QACxB;QACA,IAAIa,kBAAiB;YACnB,OAAOP,WAAWQ,WAAW;QAC/B;QACA,IAAID,gBAAeE,QAAS;YAC1BT,WAAWQ,WAAW,GAAGC;QAC3B;QACAC,YAAYC,CAAAA;YACVZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWU,UAAU;YACpCX,kBAAkBc;YAClB,OAAOD;QACT;QACAE,WAAWH,CAAAA;YACTZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWc,SAAS;YACnCf,kBAAkBc;YAClB,OAAOD;QACT;QACAG,aAAaJ,CAAAA;YACXZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWgB,QAAQ;YAClCjB,kBAAkBc;YAClB,OAAOD;QACT;QACAK,aAAaN,CAAAA;YACXZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWiB,WAAW;YACrClB,kBAAkBc;YAClB,OAAOD;QACT;QACAM,eAAeP,CAAAA;YACbZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWmB,UAAU;YACpCpB,kBAAkBc;YAClB,OAAOD;QACT;QACAQ,iBAAiBT,CAAAA;YACfZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWqB,YAAY;YACtCtB,kBAAkBc;YAClB,OAAOD;QACT;QACAU,iBAAiBX,CAAAA;YACfZ,kBAAkBY;YAClB,MAAMC,SAASZ,WAAWsB,eAAe;YACzCvB,kBAAkBc;YAClB,OAAOD;QACT;IACF;AACF"}

package/lib/utils/createHeadlessTree.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["createHeadlessTree.ts"],"sourcesContent":["import { TreeItemProps, TreeItemType, TreeItemValue } from '../TreeItem';\nimport { ImmutableSet } from './ImmutableSet';\n\nexport type HeadlessTreeItemProps = Omit<TreeItemProps, 'itemType' \| 'value'> & {\n value: TreeItemValue;\n itemType?: TreeItemType;\n parentValue?: TreeItemValue;\n};\n\n/*\n The item that is returned by `createHeadlessTree`, it represents a wrapper around the properties provided to\n * `createHeadlessTree` but with extra information that might be useful on virtual tree scenarios\n /\nexport type HeadlessTreeItem<Props extends HeadlessTreeItemProps> = {\n level: number;\n index: number;\n position: number;\n childrenValues: TreeItemValue[];\n value: TreeItemValue;\n parentValue: TreeItemValue \| undefined;\n itemType: TreeItemType;\n getTreeItemProps(): Required<Pick<Props, 'value' \| 'aria-setsize' \| 'aria-level' \| 'aria-posinset' \| 'itemType'>> &\n Props;\n};\n\n/\n @internal\n /\nexport type HeadlessTree<Props extends HeadlessTreeItemProps> = {\n /\n the number of items in the virtual tree\n /\n readonly size: number;\n /\n the root item of the virtual tree\n /\n root: HeadlessTreeItem<HeadlessTreeItemProps>;\n /\n method to get a virtual tree item by its value\n * @param key - the key of the item to get\n /\n get(value: TreeItemValue): HeadlessTreeItem<Props> \| undefined;\n /\n method to check if a virtual tree item exists by its value\n * @param value - the value of the item to check if exists\n /\n has(value: TreeItemValue): boolean;\n /\n method to add a new virtual tree item to the virtual tree\n * @param props - the props of the item to add\n /\n add(props: Props): void;\n /\n method to remove a virtual tree item from the virtual tree.\n * When an item is removed:\n * 1. all its children are also removed\n * 2. all its siblings are repositioned\n * @param value - the value of the item to remove\n /\n // remove(value: TreeItemValue): void;\n /\n method to get the parent of a virtual tree item by its value\n * @param value - the value of the item to get the parent from\n /\n getParent(value: TreeItemValue): HeadlessTreeItem<Props>;\n /\n method to get the subtree of a virtual tree item by its value\n * @param value - the value of the item to get the subtree from\n /\n subtree(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the children of a virtual tree item by its value\n * @param value - the value of the item to get the children from\n /\n children(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the visible items of a virtual tree\n * @param openItems - the open items of the tree\n /\n visibleItems(openItems: ImmutableSet<TreeItemValue>): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the ancestors of a virtual tree item by its value\n * @param value - the value of the item to get the ancestors from\n /\n ancestors(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n};\n\n/\n creates a list of virtual tree items\n * and provides a map to access each item by id\n /\nexport function createHeadlessTree<Props extends HeadlessTreeItemProps>(\n initialProps: Props[] = [],\n): HeadlessTree<Props> {\n const root = createHeadlessTreeRootItem();\n const itemsPerValue = new Map<TreeItemValue, HeadlessTreeItem<HeadlessTreeItemProps>>([[root.value, root]]);\n\n const headlessTree: HeadlessTree<HeadlessTreeItemProps> = {\n root,\n get size() {\n return itemsPerValue.size;\n },\n getParent: key => itemsPerValue.get(itemsPerValue.get(key)?.parentValue ?? root.value) ?? root,\n get: key => itemsPerValue.get(key),\n has: key => itemsPerValue.has(key),\n add(props) {\n const { parentValue = headlessTreeRootId, ...propsWithoutParentValue } = props;\n const parentItem = itemsPerValue.get(parentValue);\n if (!parentItem) {\n if (process.env.NODE_ENV === 'development') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n TreeItem \"${props.value}\" is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children\n `);\n }\n return;\n }\n parentItem.itemType = 'branch';\n\n const item: HeadlessTreeItem<HeadlessTreeItemProps> = {\n value: props.value,\n getTreeItemProps: () => ({\n ...propsWithoutParentValue,\n parentValue,\n 'aria-level': item.level,\n 'aria-posinset': item.position,\n 'aria-setsize': parentItem.childrenValues.length,\n itemType: item.itemType,\n }),\n itemType: propsWithoutParentValue.itemType ?? 'leaf',\n level: parentItem.level + 1,\n parentValue,\n childrenValues: [],\n index: -1,\n position: parentItem.childrenValues.push(props.value),\n };\n itemsPerValue.set(item.value, item);\n },\n subtree: key => HeadlessTreeSubtreeGenerator(key, headlessTree),\n children: key => HeadlessTreeChildrenGenerator(key, headlessTree),\n ancestors: key => HeadlessTreeAncestorsGenerator(key, headlessTree),\n visibleItems: openItems => HeadlessTreeVisibleItemsGenerator(openItems, headlessTree),\n };\n\n initialProps.forEach(headlessTree.add);\n\n return headlessTree as HeadlessTree<Props>;\n}\n\nexport const headlessTreeRootId = '__fuiHeadlessTreeRoot';\n\nfunction createHeadlessTreeRootItem(): HeadlessTreeItem<HeadlessTreeItemProps> {\n return {\n parentValue: undefined,\n value: headlessTreeRootId,\n itemType: 'branch',\n getTreeItemProps: () => {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return {\n id: headlessTreeRootId,\n parentValue: undefined,\n value: headlessTreeRootId,\n 'aria-setsize': -1,\n 'aria-level': -1,\n 'aria-posinset': -1,\n itemType: 'branch',\n };\n },\n childrenValues: [],\n get index() {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return -1;\n },\n get position() {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return -1;\n },\n level: 0,\n };\n}\n\n/\n Generator that returns all subtree of a given virtual tree item\n * @param key - the key of the item to get the subtree from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeSubtreeGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n const item = virtualTreeItems.get(key);\n if (!item \|\| item.childrenValues.length === 0) {\n return;\n }\n for (const childValue of item.childrenValues) {\n yield virtualTreeItems.get(childValue)!;\n yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);\n }\n}\n\n/*\n Generator that returns all children of a given virtual tree item\n * @param key - the key of the item to get the children from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeChildrenGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n const item = virtualTreeItems.get(key);\n if (!item \|\| item.childrenValues.length === 0) {\n return;\n }\n for (const childValue of item.childrenValues) {\n yield virtualTreeItems.get(childValue)!;\n }\n}\n\n/*\n Generator that returns all ancestors of a given virtual tree item\n * @param key - the key of the item to get the children from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeAncestorsGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n let parent = virtualTreeItems.getParent(key);\n while (parent !== virtualTreeItems.root) {\n yield parent;\n parent = virtualTreeItems.getParent(parent.value);\n }\n}\n\n/*\n Generator that returns all visible items of a given virtual tree\n * @param openItems - the open items of the tree\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeVisibleItemsGenerator<Props extends HeadlessTreeItemProps>(\n openItems: ImmutableSet<TreeItemValue>,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n let index = 0;\n for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)) {\n if (isItemVisible(item, openItems, virtualTreeItems)) {\n item.index = index++;\n yield item;\n }\n }\n}\n\nfunction isItemVisible(\n item: HeadlessTreeItem<HeadlessTreeItemProps>,\n openItems: ImmutableSet<TreeItemValue>,\n virtualTreeItems: HeadlessTree<HeadlessTreeItemProps>,\n) {\n if (item.level === 1) {\n return true;\n }\n while (item.parentValue && item.parentValue !== virtualTreeItems.root.value) {\n if (!openItems.has(item.parentValue)) {\n return false;\n }\n const parent = virtualTreeItems.get(item.parentValue);\n if (!parent) {\n return false;\n }\n item = parent;\n }\n return true;\n}\n"],"names":["createHeadlessTree","initialProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","headlessTree","size","getParent","key","get","parentValue","has","add","props","headlessTreeRootId","propsWithoutParentValue","parentItem","process","env","NODE_ENV","console","error","itemType","item","getTreeItemProps","level","position","childrenValues","length","index","push","set","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","forEach","undefined","id","virtualTreeItems","childValue","parent","isItemVisible"],"mappings":"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"}
1	+ {"version":3,"sources":["createHeadlessTree.ts"],"sourcesContent":["import { TreeItemProps, TreeItemType, TreeItemValue } from '../TreeItem';\nimport { ImmutableSet } from './ImmutableSet';\n\nexport type HeadlessTreeItemProps = Omit<TreeItemProps, 'itemType' \| 'value'> & {\n value: TreeItemValue;\n itemType?: TreeItemType;\n parentValue?: TreeItemValue;\n};\n\n/*\n The item that is returned by `createHeadlessTree`, it represents a wrapper around the properties provided to\n * `createHeadlessTree` but with extra information that might be useful on virtual tree scenarios\n /\nexport type HeadlessTreeItem<Props extends HeadlessTreeItemProps> = {\n level: number;\n index: number;\n position: number;\n childrenValues: TreeItemValue[];\n value: TreeItemValue;\n parentValue: TreeItemValue \| undefined;\n itemType: TreeItemType;\n getTreeItemProps(): Required<Pick<Props, 'value' \| 'aria-setsize' \| 'aria-level' \| 'aria-posinset' \| 'itemType'>> &\n Props;\n};\n\n/\n @internal\n /\nexport type HeadlessTree<Props extends HeadlessTreeItemProps> = {\n /\n the number of items in the virtual tree\n /\n readonly size: number;\n /\n the root item of the virtual tree\n /\n root: HeadlessTreeItem<HeadlessTreeItemProps>;\n /\n method to get a virtual tree item by its value\n * @param key - the key of the item to get\n /\n get(value: TreeItemValue): HeadlessTreeItem<Props> \| undefined;\n /\n method to check if a virtual tree item exists by its value\n * @param value - the value of the item to check if exists\n /\n has(value: TreeItemValue): boolean;\n /\n method to add a new virtual tree item to the virtual tree\n * @param props - the props of the item to add\n /\n add(props: Props): void;\n /\n method to remove a virtual tree item from the virtual tree.\n * When an item is removed:\n * 1. all its children are also removed\n * 2. all its siblings are repositioned\n * @param value - the value of the item to remove\n /\n // remove(value: TreeItemValue): void;\n /\n method to get the parent of a virtual tree item by its value\n * @param value - the value of the item to get the parent from\n /\n getParent(value: TreeItemValue): HeadlessTreeItem<Props>;\n /\n method to get the subtree of a virtual tree item by its value\n * @param value - the value of the item to get the subtree from\n /\n subtree(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the children of a virtual tree item by its value\n * @param value - the value of the item to get the children from\n /\n children(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the visible items of a virtual tree\n * @param openItems - the open items of the tree\n /\n visibleItems(openItems: ImmutableSet<TreeItemValue>): IterableIterator<HeadlessTreeItem<Props>>;\n /\n method to get the ancestors of a virtual tree item by its value\n * @param value - the value of the item to get the ancestors from\n /\n ancestors(value: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n};\n\n/\n creates a list of virtual tree items\n * and provides a map to access each item by id\n /\nexport function createHeadlessTree<Props extends HeadlessTreeItemProps>(\n initialProps: Props[] = [],\n): HeadlessTree<Props> {\n const root = createHeadlessTreeRootItem();\n const itemsPerValue = new Map<TreeItemValue, HeadlessTreeItem<HeadlessTreeItemProps>>([[root.value, root]]);\n\n const headlessTree: HeadlessTree<HeadlessTreeItemProps> = {\n root,\n get size() {\n return itemsPerValue.size;\n },\n getParent: key => itemsPerValue.get(itemsPerValue.get(key)?.parentValue ?? root.value) ?? root,\n get: key => itemsPerValue.get(key),\n has: key => itemsPerValue.has(key),\n add(props) {\n const { parentValue = headlessTreeRootId, ...propsWithoutParentValue } = props;\n const parentItem = itemsPerValue.get(parentValue);\n if (!parentItem) {\n if (process.env.NODE_ENV === 'development') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n TreeItem \"${props.value}\" is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children\n `);\n }\n return;\n }\n parentItem.itemType = 'branch';\n\n const item: HeadlessTreeItem<HeadlessTreeItemProps> = {\n value: props.value,\n getTreeItemProps: () => ({\n ...propsWithoutParentValue,\n parentValue,\n 'aria-level': item.level,\n 'aria-posinset': item.position,\n 'aria-setsize': parentItem.childrenValues.length,\n itemType: item.itemType,\n }),\n itemType: propsWithoutParentValue.itemType ?? 'leaf',\n level: parentItem.level + 1,\n parentValue,\n childrenValues: [],\n index: -1,\n position: parentItem.childrenValues.push(props.value),\n };\n itemsPerValue.set(item.value, item);\n },\n subtree: key => HeadlessTreeSubtreeGenerator(key, headlessTree),\n children: key => HeadlessTreeChildrenGenerator(key, headlessTree),\n ancestors: key => HeadlessTreeAncestorsGenerator(key, headlessTree),\n visibleItems: openItems => HeadlessTreeVisibleItemsGenerator(openItems, headlessTree),\n };\n\n initialProps.forEach(headlessTree.add);\n\n return headlessTree as HeadlessTree<Props>;\n}\n\nexport const headlessTreeRootId = '__fuiHeadlessTreeRoot';\n\nfunction createHeadlessTreeRootItem(): HeadlessTreeItem<HeadlessTreeItemProps> {\n return {\n parentValue: undefined,\n value: headlessTreeRootId,\n itemType: 'branch',\n getTreeItemProps: () => {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return {\n id: headlessTreeRootId,\n parentValue: undefined,\n value: headlessTreeRootId,\n 'aria-setsize': -1,\n 'aria-level': -1,\n 'aria-posinset': -1,\n itemType: 'branch',\n };\n },\n childrenValues: [],\n get index() {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return -1;\n },\n get position() {\n if (process.env.NODE_ENV !== 'production') {\n // eslint-disable-next-line no-console\n console.error(/ #__DE-INDENT__ / `\n @fluentui/react-tree [createHeadlessTree]:\n Internal error, trying to access treeitem props from invalid root element\n `);\n }\n return -1;\n },\n level: 0,\n };\n}\n\n/\n Generator that returns all subtree of a given virtual tree item\n * @param key - the key of the item to get the subtree from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeSubtreeGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n const item = virtualTreeItems.get(key);\n if (!item \|\| item.childrenValues.length === 0) {\n return;\n }\n for (const childValue of item.childrenValues) {\n yield virtualTreeItems.get(childValue)!;\n yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);\n }\n}\n\n/*\n Generator that returns all children of a given virtual tree item\n * @param key - the key of the item to get the children from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeChildrenGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n const item = virtualTreeItems.get(key);\n if (!item \|\| item.childrenValues.length === 0) {\n return;\n }\n for (const childValue of item.childrenValues) {\n yield virtualTreeItems.get(childValue)!;\n }\n}\n\n/*\n Generator that returns all ancestors of a given virtual tree item\n * @param key - the key of the item to get the children from\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeAncestorsGenerator<Props extends HeadlessTreeItemProps>(\n key: TreeItemValue,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n let parent = virtualTreeItems.getParent(key);\n while (parent !== virtualTreeItems.root) {\n yield parent;\n parent = virtualTreeItems.getParent(parent.value);\n }\n}\n\n/*\n Generator that returns all visible items of a given virtual tree\n * @param openItems - the open items of the tree\n /\n// eslint-disable-next-line @typescript-eslint/naming-convention\nfunction HeadlessTreeVisibleItemsGenerator<Props extends HeadlessTreeItemProps>(\n openItems: ImmutableSet<TreeItemValue>,\n virtualTreeItems: HeadlessTree<Props>,\n): Generator<HeadlessTreeItem<Props>, void, void> {\n let index = 0;\n for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)) {\n if (isItemVisible(item, openItems, virtualTreeItems)) {\n item.index = index++;\n yield item;\n }\n }\n}\n\nfunction isItemVisible(\n item: HeadlessTreeItem<HeadlessTreeItemProps>,\n openItems: ImmutableSet<TreeItemValue>,\n virtualTreeItems: HeadlessTree<HeadlessTreeItemProps>,\n) {\n if (item.level === 1) {\n return true;\n }\n while (item.parentValue && item.parentValue !== virtualTreeItems.root.value) {\n if (!openItems.has(item.parentValue)) {\n return false;\n }\n const parent = virtualTreeItems.get(item.parentValue);\n if (!parent) {\n return false;\n }\n item = parent;\n }\n return true;\n}\n"],"names":["createHeadlessTree","initialProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","headlessTree","size","getParent","key","get","parentValue","has","add","props","headlessTreeRootId","propsWithoutParentValue","parentItem","process","env","NODE_ENV","console","error","itemType","item","getTreeItemProps","level","position","childrenValues","length","index","push","set","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","forEach","undefined","id","virtualTreeItems","childValue","parent","isItemVisible"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/utils/createOpenItems.js.map CHANGED Viewed

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

package/lib/utils/flattenTree.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["flattenTree.ts"],"sourcesContent":["import { HeadlessFlatTreeItemProps } from '../FlatTree';\nimport { TreeItemProps, TreeItemValue } from '../TreeItem';\n\nexport type FlattenTreeItem<Props extends TreeItemProps> = Omit<Props, 'subtree' \| 'itemType'> & {\n value: TreeItemValue;\n subtree?: FlattenTreeItem<Props>[];\n};\n\nexport type FlattenedTreeItem<Props extends TreeItemProps> = HeadlessFlatTreeItemProps & Props;\n\nfunction flattenTreeRecursive<Props extends TreeItemProps>(\n items: FlattenTreeItem<Props>[],\n parent?: HeadlessFlatTreeItemProps & Props,\n level = 1,\n): FlattenedTreeItem<Props>[] {\n return items.reduce<FlattenedTreeItem<Props>[]>((acc, { subtree, ...item }, index) => {\n const flatTreeItem = {\n 'aria-level': level,\n 'aria-posinset': index + 1,\n 'aria-setsize': items.length,\n parentValue: parent?.value,\n ...item,\n } as FlattenedTreeItem<Props>;\n acc.push(flatTreeItem);\n if (subtree !== undefined) {\n acc.push(...flattenTreeRecursive<Props>(subtree, flatTreeItem, level + 1));\n }\n return acc;\n }, []);\n}\n\n/*\n Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`\n * @example\n * ```tsx\n * const defaultItems = flattenTree_unstable([\n * {\n * children: <TreeItemLayout>level 1, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n * },\n * {\n * children: <TreeItemLayout>level 2, item 2</TreeItemLayout>,\n * },\n * {\n * children: <TreeItemLayout>level 2, item 3</TreeItemLayout>,\n * },\n * ],\n * },\n * {\n * children: <TreeItemLayout>level 1, item 2</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 3, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 4, item 1</TreeItemLayout>,\n * },\n * ],\n * },\n * ],\n * },\n * ],\n * },\n * ]);\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const flattenTree_unstable = <Props extends TreeItemProps>(\n items: FlattenTreeItem<Props>[],\n): FlattenedTreeItem<Props>[] => flattenTreeRecursive(items);\n"],"names":["flattenTreeRecursive","items","parent","level","reduce","acc","subtree","item","index","flatTreeItem","length","parentValue","value","push","undefined","flattenTree_unstable"],"mappings":"AAUA,SAASA,qBACPC,KAA+B,EAC/BC,MAA0C,EAC1CC,QAAQ,CAAC;IAET,OAAOF,MAAMG,MAAM,CAA6B,CAACC,KAAK,EAAEC,OAAO,EAAE,GAAGC,MAAM,EAAEC;QAC1E,MAAMC,eAAe;YACnB,cAAcN;YACd,iBAAiBK,QAAQ;YACzB,gBAAgBP,MAAMS,MAAM;YAC5BC,WAAW,EAAET,mBAAAA,6BAAAA,OAAQU,KAAK;YAC1B,GAAGL,IAAI;QACT;QACAF,IAAIQ,IAAI,CAACJ;QACT,IAAIH,YAAYQ,WAAW;YACzBT,IAAIQ,IAAI,IAAIb,qBAA4BM,SAASG,cAAcN,QAAQ;QACzE;QACA,OAAOE;IACT,GAAG,EAAE;AACP;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,GACD,gEAAgE;AAChE,OAAO,MAAMU,uBAAuB,CAClCd,QAC+BD,qBAAqBC,OAAO"}
1	+ {"version":3,"sources":["flattenTree.ts"],"sourcesContent":["import { HeadlessFlatTreeItemProps } from '../FlatTree';\nimport { TreeItemProps, TreeItemValue } from '../TreeItem';\n\nexport type FlattenTreeItem<Props extends TreeItemProps> = Omit<Props, 'subtree' \| 'itemType'> & {\n value: TreeItemValue;\n subtree?: FlattenTreeItem<Props>[];\n};\n\nexport type FlattenedTreeItem<Props extends TreeItemProps> = HeadlessFlatTreeItemProps & Props;\n\nfunction flattenTreeRecursive<Props extends TreeItemProps>(\n items: FlattenTreeItem<Props>[],\n parent?: HeadlessFlatTreeItemProps & Props,\n level = 1,\n): FlattenedTreeItem<Props>[] {\n return items.reduce<FlattenedTreeItem<Props>[]>((acc, { subtree, ...item }, index) => {\n const flatTreeItem = {\n 'aria-level': level,\n 'aria-posinset': index + 1,\n 'aria-setsize': items.length,\n parentValue: parent?.value,\n ...item,\n } as FlattenedTreeItem<Props>;\n acc.push(flatTreeItem);\n if (subtree !== undefined) {\n acc.push(...flattenTreeRecursive<Props>(subtree, flatTreeItem, level + 1));\n }\n return acc;\n }, []);\n}\n\n/*\n Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`\n * @example\n * ```tsx\n * const defaultItems = flattenTree_unstable([\n * {\n * children: <TreeItemLayout>level 1, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n * },\n * {\n * children: <TreeItemLayout>level 2, item 2</TreeItemLayout>,\n * },\n * {\n * children: <TreeItemLayout>level 2, item 3</TreeItemLayout>,\n * },\n * ],\n * },\n * {\n * children: <TreeItemLayout>level 1, item 2</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 2, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 3, item 1</TreeItemLayout>,\n * subtree: [\n * {\n * children: <TreeItemLayout>level 4, item 1</TreeItemLayout>,\n * },\n * ],\n * },\n * ],\n * },\n * ],\n * },\n * ]);\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/naming-convention\nexport const flattenTree_unstable = <Props extends TreeItemProps>(\n items: FlattenTreeItem<Props>[],\n): FlattenedTreeItem<Props>[] => flattenTreeRecursive(items);\n"],"names":["flattenTreeRecursive","items","parent","level","reduce","acc","subtree","item","index","flatTreeItem","length","parentValue","value","push","undefined","flattenTree_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAUA,SAASA,qBACPC,KAA+B,EAC/BC,MAA0C,EAC1CC,QAAQ,CAAC;IAET,OAAOF,MAAMG,MAAM,CAA6B,CAACC,KAAK,EAAEC,OAAO,EAAE,GAAGC,MAAM,EAAEC;QAC1E,MAAMC,eAAe;YACnB,cAAcN;YACd,iBAAiBK,QAAQ;YACzB,gBAAgBP,MAAMS,MAAM;YAC5BC,WAAW,EAAET,mBAAAA,6BAAAA,OAAQU,KAAK;YAC1B,GAAGL,IAAI;QACT;QACAF,IAAIQ,IAAI,CAACJ;QACT,IAAIH,YAAYQ,WAAW;YACzBT,IAAIQ,IAAI,IAAIb,qBAA4BM,SAASG,cAAcN,QAAQ;QACzE;QACA,OAAOE;IACT,GAAG,EAAE;AACP;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,GACD,gEAAgE;AAChE,OAAO,MAAMU,uBAAuB,CAClCd,QAC+BD,qBAAqBC,OAAO"}

package/lib/utils/getTreeItemValueFromElement.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["getTreeItemValueFromElement.ts"],"sourcesContent":["import type { TreeItemValue } from '../TreeItem';\n\nexport const dataTreeItemValueAttrName = 'data-fui-tree-item-value';\n\nexport const getTreeItemValueFromElement = (element: HTMLElement) => {\n return element.getAttribute(dataTreeItemValueAttrName) as TreeItemValue \| null;\n};\n"],"names":["dataTreeItemValueAttrName","getTreeItemValueFromElement","element","getAttribute"],"mappings":"AAEA,OAAO,MAAMA,4BAA4B,2BAA2B;AAEpE,OAAO,MAAMC,8BAA8B,CAACC;IAC1C,OAAOA,QAAQC,YAAY,CAACH;AAC9B,EAAE"}
1	+ {"version":3,"sources":["getTreeItemValueFromElement.ts"],"sourcesContent":["import type { TreeItemValue } from '../TreeItem';\n\nexport const dataTreeItemValueAttrName = 'data-fui-tree-item-value';\n\nexport const getTreeItemValueFromElement = (element: HTMLElement) => {\n return element.getAttribute(dataTreeItemValueAttrName) as TreeItemValue \| null;\n};\n"],"names":["dataTreeItemValueAttrName","getTreeItemValueFromElement","element","getAttribute"],"rangeMappings":";;;","mappings":"AAEA,OAAO,MAAMA,4BAA4B,2BAA2B;AAEpE,OAAO,MAAMC,8BAA8B,CAACC;IAC1C,OAAOA,QAAQC,YAAY,CAACH;AAC9B,EAAE"}

package/lib/utils/nextTypeAheadElement.js.map CHANGED Viewed

	@@ -1 +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"}
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"],"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 CHANGED Viewed

	@@ -1 +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"}
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"],"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 CHANGED Viewed

	@@ -1 +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"}
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"],"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 CHANGED Viewed

	@@ -1 +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"}
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"],"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 CHANGED Viewed

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

package/lib-commonjs/FlatTreeItem.js.map CHANGED Viewed

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

package/lib-commonjs/Tree.js.map CHANGED Viewed

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

package/lib-commonjs/TreeItem.js.map CHANGED Viewed

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

package/lib-commonjs/TreeItemLayout.js.map CHANGED Viewed

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

package/lib-commonjs/TreeItemPersonaLayout.js.map CHANGED Viewed

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

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

	@@ -1 +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"}
1	+ {"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 CHANGED Viewed

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

	@@ -1 +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"}
1	+ {"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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"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 CHANGED Viewed

@@ -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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"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.map CHANGED Viewed

	@@ -1 +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 'use no memo';\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~~;~~IACA~~,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~~"}
1	+ {"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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"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.map CHANGED Viewed

	@@ -1 +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 'use no memo';\n\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~~;~~IAEA~~,MAAMC,aAAaH;IACnBE,MAAMH,IAAI,CAACK,SAAS,GAAGC,IAAAA,mBAAY,EAACR,mBAAmBE,IAAI,EAAEI,YAAYD,MAAMH,IAAI,CAACK,SAAS;IAC7F,OAAOF;~~AACT,GACA,oDAAoD~~"}
1	+ {"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.map CHANGED Viewed

	@@ -1 +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 'use no memo';\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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"}
1	+ {"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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

	@@ -1 +1 @@
1	- {"version":3,"sources":["index.js"],"sourcesContent":["export * from './FlatTreeItem';\nexport * from './FlatTreeItem.types';\n"],"names":[],"mappings":";;;;;uBAAc;uBACA"}
1	+ {"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 CHANGED Viewed

	@@ -1 +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"}
1	+ {"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 CHANGED Viewed

@@ -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 CHANGED Viewed

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

	@@ -1 +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"}
1	+ {"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 CHANGED Viewed

	@@ -1 +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~~"}
1	+ {"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 CHANGED Viewed

@@ -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 CHANGED Viewed

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