@fluentui/react-tree 9.0.0-beta.9 → 9.0.1

package/lib/utils/assert.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","assertIsDefinedRef","refObject","msg","current","undefined","process","env","NODE_ENV","TypeError"],"sources":["../../src/utils/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"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAEvB,OAAO,SAASC,mBACdC,SAAgD,EAChDC,GAAA,GAAO,sDAAqDD,SAAU,EAAC,EACvB;EAChD;EACA,IAAIA,SAAA,CAAUE,OAAO,IAAIC,SAAA,IAAaC,OAAA,CAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;IAC5E,MAAM,IAAIC,SAAA,CAAUN,GAAA;EACtB;AACF"}
+{"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,EACvB;IAChD,kCAAkC;IAClC,IAAIA,UAAUE,OAAO,IAAIC,aAAaC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;QAC5E,MAAM,IAAIC,UAAUN,KAAK;IAC3B,CAAC;AACH,CAAC"}

package/lib/utils/createCheckedItems.js

@@ -0,0 +1,18 @@
+import { ImmutableMap } from './ImmutableMap';
+export function createCheckedItems(iterable) {
+    if (iterable === undefined) {
+        return ImmutableMap.empty;
+    }
+    if (ImmutableMap.isImmutableMap(iterable)) {
+        return iterable;
+    }
+    const internalMap = new Map();
+    for (const item of iterable){
+        if (Array.isArray(item)) {
+            internalMap.set(item[0], item[1]);
+        } else {
+            internalMap.set(item, true);
+        }
+    }
+    return ImmutableMap.dangerouslyCreate_unstable(internalMap);
+}

package/lib/utils/createCheckedItems.js.map

@@ -0,0 +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,EAAE;IAC3G,IAAIA,aAAaC,WAAW;QAC1B,OAAOH,aAAaI,KAAK;IAC3B,CAAC;IACD,IAAIJ,aAAaK,cAAc,CAAoCH,WAAW;QAC5E,OAAOA;IACT,CAAC;IACD,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,IAAI;QAC5B,CAAC;IACH;IACA,OAAOR,aAAaY,0BAA0B,CAACN;AACjD,CAAC"}

package/lib/utils/createHTMLElementWalker.js

@@ -0,0 +1,67 @@
+import { isHTMLElement } from '@fluentui/react-utilities';
+export function createHTMLElementWalker(root, filter = ()=>NodeFilter.FILTER_ACCEPT) {
+    let temporaryFilter;
+    const treeWalker = document.createTreeWalker(root, NodeFilter.SHOW_ELEMENT, {
+        acceptNode (node) {
+            if (!isHTMLElement(node)) {
+                return NodeFilter.FILTER_REJECT;
+            }
+            const filterResult = filter(node);
+            var _temporaryFilter;
+            return filterResult === NodeFilter.FILTER_ACCEPT ? (_temporaryFilter = temporaryFilter === null || temporaryFilter === void 0 ? void 0 : temporaryFilter(node)) !== null && _temporaryFilter !== void 0 ? _temporaryFilter : filterResult : filterResult;
+        }
+    });
+    return {
+        get root () {
+            return treeWalker.root;
+        },
+        get currentElement () {
+            return treeWalker.currentNode;
+        },
+        set currentElement (element){
+            treeWalker.currentNode = element;
+        },
+        firstChild: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.firstChild();
+            temporaryFilter = undefined;
+            return result;
+        },
+        lastChild: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.lastChild();
+            temporaryFilter = undefined;
+            return result;
+        },
+        nextElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.nextNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        nextSibling: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.nextSibling();
+            temporaryFilter = undefined;
+            return result;
+        },
+        parentElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.parentNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        previousElement: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.previousNode();
+            temporaryFilter = undefined;
+            return result;
+        },
+        previousSibling: (localFilter)=>{
+            temporaryFilter = localFilter;
+            const result = treeWalker.previousSibling();
+            temporaryFilter = undefined;
+            return result;
+        }
+    };
+}

package/lib/utils/createHTMLElementWalker.js.map

@@ -0,0 +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  filter: HTMLElementFilter = () => NodeFilter.FILTER_ACCEPT,\n): HTMLElementWalker {\n  let temporaryFilter: HTMLElementFilter | undefined;\n  const treeWalker = document.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","filter","NodeFilter","FILTER_ACCEPT","temporaryFilter","treeWalker","document","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,SAA4B,IAAMC,WAAWC,aAAa,EACvC;IACnB,IAAIC;IACJ,MAAMC,aAAaC,SAASC,gBAAgB,CAACP,MAAME,WAAWM,YAAY,EAAE;QAC1EC,YAAWC,IAAU,EAAE;YACrB,IAAI,CAACZ,cAAcY,OAAO;gBACxB,OAAOR,WAAWS,aAAa;YACjC,CAAC;YACD,MAAMC,eAAeX,OAAOS;gBACuBN;YAAnD,OAAOQ,iBAAiBV,WAAWC,aAAa,GAAGC,CAAAA,mBAAAA,4BAAAA,6BAAAA,KAAAA,IAAAA,gBAAkBM,mBAAlBN,8BAAAA,mBAA2BQ,YAAY,GAAGA,YAAY;QAC3G;IACF;IACA,OAAO;QACL,IAAIZ,QAAO;YACT,OAAOK,WAAWL,IAAI;QACxB;QACA,IAAIa,kBAAiB;YACnB,OAAOR,WAAWS,WAAW;QAC/B;QACA,IAAID,gBAAeE,QAAS;YAC1BV,WAAWS,WAAW,GAAGC;QAC3B;QACAC,YAAYC,CAAAA,cAAe;YACzBb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWW,UAAU;YACpCZ,kBAAkBe;YAClB,OAAOD;QACT;QACAE,WAAWH,CAAAA,cAAe;YACxBb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWe,SAAS;YACnChB,kBAAkBe;YAClB,OAAOD;QACT;QACAG,aAAaJ,CAAAA,cAAe;YAC1Bb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWiB,QAAQ;YAClClB,kBAAkBe;YAClB,OAAOD;QACT;QACAK,aAAaN,CAAAA,cAAe;YAC1Bb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWkB,WAAW;YACrCnB,kBAAkBe;YAClB,OAAOD;QACT;QACAM,eAAeP,CAAAA,cAAe;YAC5Bb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWoB,UAAU;YACpCrB,kBAAkBe;YAClB,OAAOD;QACT;QACAQ,iBAAiBT,CAAAA,cAAe;YAC9Bb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWsB,YAAY;YACtCvB,kBAAkBe;YAClB,OAAOD;QACT;QACAU,iBAAiBX,CAAAA,cAAe;YAC9Bb,kBAAkBa;YAClB,MAAMC,SAASb,WAAWuB,eAAe;YACzCxB,kBAAkBe;YAClB,OAAOD;QACT;IACF;AACF,CAAC"}

package/lib/utils/createHeadlessTree.js

@@ -0,0 +1,189 @@
+/**
+ * creates a list of virtual tree items
+ * and provides a map to access each item by id
+ */ export function createHeadlessTree(initialProps = []) {
+    const root = createHeadlessTreeRootItem();
+    const itemsPerValue = new Map([
+        [
+            root.value,
+            root
+        ]
+    ]);
+    var _itemsPerValue_get_parentValue, _itemsPerValue_get;
+    const headlessTree = {
+        root,
+        get size () {
+            return itemsPerValue.size;
+        },
+        getParent: (key)=>{
+            var _itemsPerValue_get1;
+            return (_itemsPerValue_get = itemsPerValue.get((_itemsPerValue_get_parentValue = (_itemsPerValue_get1 = itemsPerValue.get(key)) === null || _itemsPerValue_get1 === void 0 ? void 0 : _itemsPerValue_get1.parentValue) !== null && _itemsPerValue_get_parentValue !== void 0 ? _itemsPerValue_get_parentValue : root.value)) !== null && _itemsPerValue_get !== void 0 ? _itemsPerValue_get : root;
+        },
+        get: (key)=>itemsPerValue.get(key),
+        has: (key)=>itemsPerValue.has(key),
+        add (props) {
+            const { parentValue =headlessTreeRootId , ...propsWithoutParentValue } = props;
+            const parentItem = itemsPerValue.get(parentValue);
+            if (!parentItem) {
+                if (process.env.NODE_ENV === 'development') {
+                    // eslint-disable-next-line no-console
+                    console.error(`HeadlessTree: item ${props.value} is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized, parents should come before children`);
+                }
+                return;
+            }
+            parentItem.itemType = 'branch';
+            var _propsWithoutParentValue_itemType;
+            const item = {
+                value: props.value,
+                getTreeItemProps: ()=>({
+                        ...propsWithoutParentValue,
+                        'aria-level': item.level,
+                        'aria-posinset': item.position,
+                        'aria-setsize': parentItem.childrenValues.length,
+                        itemType: item.itemType
+                    }),
+                itemType: (_propsWithoutParentValue_itemType = propsWithoutParentValue.itemType) !== null && _propsWithoutParentValue_itemType !== void 0 ? _propsWithoutParentValue_itemType : 'leaf',
+                level: parentItem.level + 1,
+                parentValue,
+                childrenValues: [],
+                index: -1,
+                position: parentItem.childrenValues.push(props.value)
+            };
+            itemsPerValue.set(item.value, item);
+        },
+        // TODO: eventually it would be nice to have this method exported for the user to modify
+        // the internal state of the virtual tree
+        // remove(value) {
+        //   const itemToBeRemoved = itemsPerValue.get(value);
+        //   if (!itemToBeRemoved) {
+        //     return;
+        //   }
+        //   const parentItem = headlessTree.getParent(value);
+        //   parentItem.childrenValues.splice(itemToBeRemoved.position, 1);
+        //   itemsPerValue.delete(value);
+        //   if (parentItem.childrenValues.length === 0) {
+        //     parentItem.itemType = 'leaf';
+        //   }
+        //   for (let index = itemToBeRemoved.position; index < parentItem.childrenValues.length; index++) {
+        //     const child = itemsPerValue.get(parentItem.childrenValues[index]);
+        //     if (child) {
+        //       child.position = index + 1;
+        //     }
+        //   }
+        //   for (const descendant of HeadlessTreeSubtreeGenerator(value, headlessTree)) {
+        //     itemsPerValue.delete(descendant.value);
+        //   }
+        // },
+        subtree: (key)=>HeadlessTreeSubtreeGenerator(key, headlessTree),
+        children: (key)=>HeadlessTreeChildrenGenerator(key, headlessTree),
+        ancestors: (key)=>HeadlessTreeAncestorsGenerator(key, headlessTree),
+        visibleItems: (openItems)=>HeadlessTreeVisibleItemsGenerator(openItems, headlessTree)
+    };
+    initialProps.forEach(headlessTree.add);
+    return headlessTree;
+}
+export const headlessTreeRootId = '__fuiHeadlessTreeRoot';
+function createHeadlessTreeRootItem() {
+    return {
+        parentValue: undefined,
+        value: headlessTreeRootId,
+        itemType: 'branch',
+        getTreeItemProps: ()=>{
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return {
+                id: headlessTreeRootId,
+                value: headlessTreeRootId,
+                'aria-setsize': -1,
+                'aria-level': -1,
+                'aria-posinset': -1,
+                itemType: 'branch'
+            };
+        },
+        childrenValues: [],
+        get index () {
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return -1;
+        },
+        get position () {
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('HeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return -1;
+        },
+        level: 0
+    };
+}
+/**
+ * Generator that returns all subtree of a given virtual tree item
+ * @param key the key of the item to get the subtree from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeSubtreeGenerator(key, virtualTreeItems) {
+    const item = virtualTreeItems.get(key);
+    if (!item || item.childrenValues.length === 0) {
+        return;
+    }
+    for (const childValue of item.childrenValues){
+        yield virtualTreeItems.get(childValue);
+        yield* HeadlessTreeSubtreeGenerator(childValue, virtualTreeItems);
+    }
+}
+/**
+ * Generator that returns all children of a given virtual tree item
+ * @param key the key of the item to get the children from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeChildrenGenerator(key, virtualTreeItems) {
+    const item = virtualTreeItems.get(key);
+    if (!item || item.childrenValues.length === 0) {
+        return;
+    }
+    for (const childValue of item.childrenValues){
+        yield virtualTreeItems.get(childValue);
+    }
+}
+/**
+ * Generator that returns all ancestors of a given virtual tree item
+ * @param key the key of the item to get the children from
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeAncestorsGenerator(key, virtualTreeItems) {
+    let parent = virtualTreeItems.getParent(key);
+    while(parent !== virtualTreeItems.root){
+        yield parent;
+        parent = virtualTreeItems.getParent(parent.value);
+    }
+}
+/**
+ * Generator that returns all visible items of a given virtual tree
+ * @param openItems the open items of the tree
+ */ // eslint-disable-next-line @typescript-eslint/naming-convention
+function* HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems) {
+    let index = 0;
+    for (const item of HeadlessTreeSubtreeGenerator(virtualTreeItems.root.value, virtualTreeItems)){
+        if (isItemVisible(item, openItems, virtualTreeItems)) {
+            item.index = index++;
+            yield item;
+        }
+    }
+}
+function isItemVisible(item, openItems, virtualTreeItems) {
+    if (item.level === 1) {
+        return true;
+    }
+    while(item.parentValue && item.parentValue !== virtualTreeItems.root.value){
+        if (!openItems.has(item.parentValue)) {
+            return false;
+        }
+        const parent = virtualTreeItems.get(item.parentValue);
+        if (!parent) {
+            return false;
+        }
+        item = parent;
+    }
+    return true;
+}

package/lib/utils/createHeadlessTree.js.map

@@ -0,0 +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    Omit<Props, 'parentValue'>;\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(\n            `HeadlessTree: item ${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          '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    // TODO: eventually it would be nice to have this method exported for the user to modify\n    // the internal state of the virtual tree\n    // remove(value) {\n    //   const itemToBeRemoved = itemsPerValue.get(value);\n    //   if (!itemToBeRemoved) {\n    //     return;\n    //   }\n    //   const parentItem = headlessTree.getParent(value);\n    //   parentItem.childrenValues.splice(itemToBeRemoved.position, 1);\n    //   itemsPerValue.delete(value);\n    //   if (parentItem.childrenValues.length === 0) {\n    //     parentItem.itemType = 'leaf';\n    //   }\n    //   for (let index = itemToBeRemoved.position; index < parentItem.childrenValues.length; index++) {\n    //     const child = itemsPerValue.get(parentItem.childrenValues[index]);\n    //     if (child) {\n    //       child.position = index + 1;\n    //     }\n    //   }\n    //   for (const descendant of HeadlessTreeSubtreeGenerator(value, headlessTree)) {\n    //     itemsPerValue.delete(descendant.value);\n    //   }\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('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\n      }\n      return {\n        id: headlessTreeRootId,\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('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\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('HeadlessTree: internal error, trying to access treeitem props from invalid root element');\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":"AAuFA;;;CAGC,GACD,OAAO,SAASA,mBACdC,eAAwB,EAAE,EACL;IACrB,MAAMC,OAAOC;IACb,MAAMC,gBAAgB,IAAIC,IAA4D;QAAC;YAACH,KAAKI,KAAK;YAAEJ;SAAK;KAAC;QAOpEE,gCAAlBA;IALpB,MAAMG,eAAoD;QACxDL;QACA,IAAIM,QAAO;YACT,OAAOJ,cAAcI,IAAI;QAC3B;QACAC,WAAWC,CAAAA;gBAAyBN;YAAlBA,OAAAA,CAAAA,qBAAAA,cAAcO,GAAG,CAACP,CAAAA,iCAAAA,CAAAA,sBAAAA,cAAcO,GAAG,CAACD,kBAAlBN,iCAAAA,KAAAA,IAAAA,oBAAwBQ,WAAW,cAAnCR,4CAAAA,iCAAuCF,KAAKI,KAAK,eAAnEF,gCAAAA,qBAAwEF,IAAI;;QAC9FS,KAAKD,CAAAA,MAAON,cAAcO,GAAG,CAACD;QAC9BG,KAAKH,CAAAA,MAAON,cAAcS,GAAG,CAACH;QAC9BI,KAAIC,KAAK,EAAE;YACT,MAAM,EAAEH,aAAcI,mBAAkB,EAAE,GAAGC,yBAAyB,GAAGF;YACzE,MAAMG,aAAad,cAAcO,GAAG,CAACC;YACrC,IAAI,CAACM,YAAY;gBACf,IAAIC,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;oBAC1C,sCAAsC;oBACtCC,QAAQC,KAAK,CACX,CAAC,mBAAmB,EAAER,MAAMT,KAAK,CAAC,iJAAiJ,CAAC;gBAExL,CAAC;gBACD;YACF,CAAC;YACDY,WAAWM,QAAQ,GAAG;gBAWVP;YATZ,MAAMQ,OAAgD;gBACpDnB,OAAOS,MAAMT,KAAK;gBAClBoB,kBAAkB,IAAO,CAAA;wBACvB,GAAGT,uBAAuB;wBAC1B,cAAcQ,KAAKE,KAAK;wBACxB,iBAAiBF,KAAKG,QAAQ;wBAC9B,gBAAgBV,WAAWW,cAAc,CAACC,MAAM;wBAChDN,UAAUC,KAAKD,QAAQ;oBACzB,CAAA;gBACAA,UAAUP,CAAAA,oCAAAA,wBAAwBO,QAAQ,cAAhCP,+CAAAA,oCAAoC,MAAM;gBACpDU,OAAOT,WAAWS,KAAK,GAAG;gBAC1Bf;gBACAiB,gBAAgB,EAAE;gBAClBE,OAAO,CAAC;gBACRH,UAAUV,WAAWW,cAAc,CAACG,IAAI,CAACjB,MAAMT,KAAK;YACtD;YACAF,cAAc6B,GAAG,CAACR,KAAKnB,KAAK,EAAEmB;QAChC;QACA,wFAAwF;QACxF,yCAAyC;QACzC,kBAAkB;QAClB,sDAAsD;QACtD,4BAA4B;QAC5B,cAAc;QACd,MAAM;QACN,sDAAsD;QACtD,mEAAmE;QACnE,iCAAiC;QACjC,kDAAkD;QAClD,oCAAoC;QACpC,MAAM;QACN,oGAAoG;QACpG,yEAAyE;QACzE,mBAAmB;QACnB,oCAAoC;QACpC,QAAQ;QACR,MAAM;QACN,kFAAkF;QAClF,8CAA8C;QAC9C,MAAM;QACN,KAAK;QACLS,SAASxB,CAAAA,MAAOyB,6BAA6BzB,KAAKH;QAClD6B,UAAU1B,CAAAA,MAAO2B,8BAA8B3B,KAAKH;QACpD+B,WAAW5B,CAAAA,MAAO6B,+BAA+B7B,KAAKH;QACtDiC,cAAcC,CAAAA,YAAaC,kCAAkCD,WAAWlC;IAC1E;IAEAN,aAAa0C,OAAO,CAACpC,aAAaO,GAAG;IAErC,OAAOP;AACT,CAAC;AAED,OAAO,MAAMS,qBAAqB,wBAAwB;AAE1D,SAASb,6BAAsE;IAC7E,OAAO;QACLS,aAAagC;QACbtC,OAAOU;QACPQ,UAAU;QACVE,kBAAkB,IAAM;YACtB,IAAIP,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,sCAAsC;gBACtCC,QAAQC,KAAK,CAAC;YAChB,CAAC;YACD,OAAO;gBACLsB,IAAI7B;gBACJV,OAAOU;gBACP,gBAAgB,CAAC;gBACjB,cAAc,CAAC;gBACf,iBAAiB,CAAC;gBAClBQ,UAAU;YACZ;QACF;QACAK,gBAAgB,EAAE;QAClB,IAAIE,SAAQ;YACV,IAAIZ,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,sCAAsC;gBACtCC,QAAQC,KAAK,CAAC;YAChB,CAAC;YACD,OAAO,CAAC;QACV;QACA,IAAIK,YAAW;YACb,IAAIT,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,sCAAsC;gBACtCC,QAAQC,KAAK,CAAC;YAChB,CAAC;YACD,OAAO,CAAC;QACV;QACAI,OAAO;IACT;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUQ,6BACRzB,GAAkB,EAClBoC,gBAAqC,EACW;IAChD,MAAMrB,OAAOqB,iBAAiBnC,GAAG,CAACD;IAClC,IAAI,CAACe,QAAQA,KAAKI,cAAc,CAACC,MAAM,KAAK,GAAG;QAC7C;IACF,CAAC;IACD,KAAK,MAAMiB,cAActB,KAAKI,cAAc,CAAE;QAC5C,MAAMiB,iBAAiBnC,GAAG,CAACoC;QAC3B,OAAOZ,6BAA6BY,YAAYD;IAClD;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUT,8BACR3B,GAAkB,EAClBoC,gBAAqC,EACW;IAChD,MAAMrB,OAAOqB,iBAAiBnC,GAAG,CAACD;IAClC,IAAI,CAACe,QAAQA,KAAKI,cAAc,CAACC,MAAM,KAAK,GAAG;QAC7C;IACF,CAAC;IACD,KAAK,MAAMiB,cAActB,KAAKI,cAAc,CAAE;QAC5C,MAAMiB,iBAAiBnC,GAAG,CAACoC;IAC7B;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUR,+BACR7B,GAAkB,EAClBoC,gBAAqC,EACW;IAChD,IAAIE,SAASF,iBAAiBrC,SAAS,CAACC;IACxC,MAAOsC,WAAWF,iBAAiB5C,IAAI,CAAE;QACvC,MAAM8C;QACNA,SAASF,iBAAiBrC,SAAS,CAACuC,OAAO1C,KAAK;IAClD;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUoC,kCACRD,SAAsC,EACtCK,gBAAqC,EACW;IAChD,IAAIf,QAAQ;IACZ,KAAK,MAAMN,QAAQU,6BAA6BW,iBAAiB5C,IAAI,CAACI,KAAK,EAAEwC,kBAAmB;QAC9F,IAAIG,cAAcxB,MAAMgB,WAAWK,mBAAmB;YACpDrB,KAAKM,KAAK,GAAGA;YACb,MAAMN;QACR,CAAC;IACH;AACF;AAEA,SAASwB,cACPxB,IAA6C,EAC7CgB,SAAsC,EACtCK,gBAAqD,EACrD;IACA,IAAIrB,KAAKE,KAAK,KAAK,GAAG;QACpB,OAAO,IAAI;IACb,CAAC;IACD,MAAOF,KAAKb,WAAW,IAAIa,KAAKb,WAAW,KAAKkC,iBAAiB5C,IAAI,CAACI,KAAK,CAAE;QAC3E,IAAI,CAACmC,UAAU5B,GAAG,CAACY,KAAKb,WAAW,GAAG;YACpC,OAAO,KAAK;QACd,CAAC;QACD,MAAMoC,SAASF,iBAAiBnC,GAAG,CAACc,KAAKb,WAAW;QACpD,IAAI,CAACoC,QAAQ;YACX,OAAO,KAAK;QACd,CAAC;QACDvB,OAAOuB;IACT;IACA,OAAO,IAAI;AACb"}

package/lib/utils/createOpenItems.js

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

package/lib/utils/createOpenItems.js.map

@@ -0,0 +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,EAAE;IAClE,IAAIA,aAAaC,WAAW;QAC1B,OAAOH,aAAaI,KAAK;IAC3B,CAAC;IACD,IAAIJ,aAAaK,cAAc,CAAgBH,WAAW;QACxD,OAAOA;IACT,CAAC;IACD,OAAOF,aAAaM,MAAM,CAACJ;AAC7B,CAAC"}

package/lib/utils/flattenTree.js

@@ -1,26 +1,18 @@
-import * as React from 'react';
-let count = 1;
 function flattenTreeRecursive(items, parent, level = 1) {
-  return items.reduce((acc, {
-    subtree,
-    ...item
-  }, index) => {
-    var _item_id;
-    const flatTreeItem = {
-      'aria-level': level,
-      'aria-posinset': index + 1,
-      'aria-setsize': items.length,
-      parentId: parent === null || parent === void 0 ? void 0 : parent.id,
-      id: (_item_id = item.id) !== null && _item_id !== void 0 ? _item_id : `fui-FlatTreeItem-${count++}`,
-      leaf: subtree === undefined,
-      ...item
-    };
-    acc.push(flatTreeItem);
-    if (subtree !== undefined) {
-      acc.push(...flattenTreeRecursive(subtree, flatTreeItem, level + 1));
-    }
-    return acc;
-  }, []);
+    return items.reduce((acc, { subtree , ...item }, index)=>{
+        const flatTreeItem = {
+            'aria-level': level,
+            'aria-posinset': index + 1,
+            'aria-setsize': items.length,
+            parentValue: parent === null || parent === void 0 ? void 0 : parent.value,
+            ...item
+        };
+        acc.push(flatTreeItem);
+        if (subtree !== undefined) {
+            acc.push(...flattenTreeRecursive(subtree, flatTreeItem, level + 1));
+        }
+        return acc;
+    }, []);
 }
 /**
  * Converts a nested structure to a flat one which can be consumed by `useFlatTreeItems`
@@ -62,30 +54,4 @@ function flattenTreeRecursive(items, parent, level = 1) {
  * ]);
  * ```
  */ // eslint-disable-next-line @typescript-eslint/naming-convention
-export const flattenTree_unstable = items => flattenTreeRecursive(items);
-/**
- * @internal
- */
-export const flattenTreeFromElement = (root, parent, level = 1) => {
-  const children = React.Children.toArray(root.props.children);
-  return children.reduce((acc, curr, index) => {
-    const [content, subtree] = React.Children.toArray(curr.props.children);
-    var _curr_props_id;
-    const flatTreeItem = {
-      'aria-level': level,
-      'aria-posinset': index + 1,
-      'aria-setsize': children.length,
-      parentId: parent === null || parent === void 0 ? void 0 : parent.id,
-      id: (_curr_props_id = curr.props.id) !== null && _curr_props_id !== void 0 ? _curr_props_id : `fui-FlatTreeItem-${count++}`,
-      leaf: subtree === undefined,
-      ...curr.props,
-      children: content
-    };
-    acc.push(flatTreeItem);
-    if (subtree !== undefined) {
-      acc.push(...flattenTreeFromElement(subtree, flatTreeItem, level + 1));
-    }
-    return acc;
-  }, []);
-};
-//# sourceMappingURL=flattenTree.js.map
+export const flattenTree_unstable = (items)=>flattenTreeRecursive(items);

package/lib/utils/flattenTree.js.map

@@ -1 +1 @@
-{"version":3,"names":["React","count","flattenTreeRecursive","items","parent","level","reduce","acc","subtree","item","index","_item_id","flatTreeItem","length","parentId","id","leaf","undefined","push","flattenTree_unstable","flattenTreeFromElement","root","children","Children","toArray","props","curr","content","_curr_props_id"],"sources":["../../src/utils/flattenTree.ts"],"sourcesContent":["import * as React from 'react';\nimport { FlatTreeItemProps } from '../hooks/useFlatTree';\nimport { TreeItemProps } from '../TreeItem';\n\nexport type NestedTreeItem = Omit<TreeItemProps, 'subtree'> & {\n  subtree?: NestedTreeItem[];\n};\n\nlet count = 1;\nfunction flattenTreeRecursive(items: NestedTreeItem[], parent?: FlatTreeItemProps, level = 1): FlatTreeItemProps[] {\n  return items.reduce<FlatTreeItemProps[]>((acc, { subtree, ...item }, index) => {\n    const flatTreeItem: FlatTreeItemProps = {\n      'aria-level': level,\n      'aria-posinset': index + 1,\n      'aria-setsize': items.length,\n      parentId: parent?.id,\n      id: item.id ?? `fui-FlatTreeItem-${count++}`,\n      leaf: subtree === undefined,\n      ...item,\n    };\n    acc.push(flatTreeItem);\n    if (subtree !== undefined) {\n      acc.push(...flattenTreeRecursive(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 = (items: NestedTreeItem[]): FlatTreeItemProps[] => flattenTreeRecursive(items);\n\n/**\n * @internal\n */\nexport const flattenTreeFromElement = (\n  root: React.ReactElement<{\n    children?: React.ReactElement<TreeItemProps> | React.ReactElement<TreeItemProps>[];\n  }>,\n  parent?: FlatTreeItemProps,\n  level = 1,\n): FlatTreeItemProps[] => {\n  const children = React.Children.toArray(root.props.children) as React.ReactElement<TreeItemProps>[];\n  return children.reduce<FlatTreeItemProps[]>((acc, curr, index) => {\n    const [content, subtree] = React.Children.toArray(curr.props.children) as [\n      React.ReactNode,\n      typeof root | undefined,\n    ];\n    const flatTreeItem: FlatTreeItemProps = {\n      'aria-level': level,\n      'aria-posinset': index + 1,\n      'aria-setsize': children.length,\n      parentId: parent?.id,\n      id: curr.props.id ?? `fui-FlatTreeItem-${count++}`,\n      leaf: subtree === undefined,\n      ...curr.props,\n      children: content,\n    };\n    acc.push(flatTreeItem);\n    if (subtree !== undefined) {\n      acc.push(...flattenTreeFromElement(subtree, flatTreeItem, level + 1));\n    }\n    return acc;\n  }, []);\n};\n"],"mappings":"AAAA,YAAYA,KAAA,MAAW;AAQvB,IAAIC,KAAA,GAAQ;AACZ,SAASC,qBAAqBC,KAAuB,EAAEC,MAA0B,EAAEC,KAAA,GAAQ,CAAC,EAAuB;EACjH,OAAOF,KAAA,CAAMG,MAAM,CAAsB,CAACC,GAAA,EAAK;IAAEC,OAAA;IAAS,GAAGC;EAAA,CAAM,EAAEC,KAAA,KAAU;QAMvEC,QAAA;IALN,MAAMC,YAAA,GAAkC;MACtC,cAAcP,KAAA;MACd,iBAAiBK,KAAA,GAAQ;MACzB,gBAAgBP,KAAA,CAAMU,MAAM;MAC5BC,QAAA,EAAUV,MAAA,aAAAA,MAAA,uBAAAA,MAAA,CAAQW,EAAE;MACpBA,EAAA,EAAI,CAAAJ,QAAA,GAAAF,IAAA,CAAKM,EAAE,cAAPJ,QAAA,cAAAA,QAAA,GAAY,oBAAmBV,KAAA,EAAQ,EAAC;MAC5Ce,IAAA,EAAMR,OAAA,KAAYS,SAAA;MAClB,GAAGR;IACL;IACAF,GAAA,CAAIW,IAAI,CAACN,YAAA;IACT,IAAIJ,OAAA,KAAYS,SAAA,EAAW;MACzBV,GAAA,CAAIW,IAAI,IAAIhB,oBAAA,CAAqBM,OAAA,EAASI,YAAA,EAAcP,KAAA,GAAQ;IAClE;IACA,OAAOE,GAAA;EACT,GAAG,EAAE;AACP;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAAA,CAwCA;AACA,OAAO,MAAMY,oBAAA,GAAwBhB,KAAA,IAAiDD,oBAAA,CAAqBC,KAAA;AAE3G;;;AAGA,OAAO,MAAMiB,sBAAA,GAAyBA,CACpCC,IAAA,EAGAjB,MAAA,EACAC,KAAA,GAAQ,CAAC,KACe;EACxB,MAAMiB,QAAA,GAAWtB,KAAA,CAAMuB,QAAQ,CAACC,OAAO,CAACH,IAAA,CAAKI,KAAK,CAACH,QAAQ;EAC3D,OAAOA,QAAA,CAAShB,MAAM,CAAsB,CAACC,GAAA,EAAKmB,IAAA,EAAMhB,KAAA,KAAU;IAChE,MAAM,CAACiB,OAAA,EAASnB,OAAA,CAAQ,GAAGR,KAAA,CAAMuB,QAAQ,CAACC,OAAO,CAACE,IAAA,CAAKD,KAAK,CAACH,QAAQ;QAS/DM,cAAA;IALN,MAAMhB,YAAA,GAAkC;MACtC,cAAcP,KAAA;MACd,iBAAiBK,KAAA,GAAQ;MACzB,gBAAgBY,QAAA,CAAST,MAAM;MAC/BC,QAAA,EAAUV,MAAA,aAAAA,MAAA,uBAAAA,MAAA,CAAQW,EAAE;MACpBA,EAAA,EAAI,CAAAa,cAAA,GAAAF,IAAA,CAAKD,KAAK,CAACV,EAAE,cAAba,cAAA,cAAAA,cAAA,GAAkB,oBAAmB3B,KAAA,EAAQ,EAAC;MAClDe,IAAA,EAAMR,OAAA,KAAYS,SAAA;MAClB,GAAGS,IAAA,CAAKD,KAAK;MACbH,QAAA,EAAUK;IACZ;IACApB,GAAA,CAAIW,IAAI,CAACN,YAAA;IACT,IAAIJ,OAAA,KAAYS,SAAA,EAAW;MACzBV,GAAA,CAAIW,IAAI,IAAIE,sBAAA,CAAuBZ,OAAA,EAASI,YAAA,EAAcP,KAAA,GAAQ;IACpE;IACA,OAAOE,GAAA;EACT,GAAG,EAAE;AACP"}
+{"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,EACmB;IAC5B,OAAOF,MAAMG,MAAM,CAA6B,CAACC,KAAK,EAAEC,QAAO,EAAE,GAAGC,MAAM,EAAEC,QAAU;QACpF,MAAMC,eAAe;YACnB,cAAcN;YACd,iBAAiBK,QAAQ;YACzB,gBAAgBP,MAAMS,MAAM;YAC5BC,aAAaT,mBAAAA,oBAAAA,KAAAA,IAAAA,OAAQU,KAAK;YAC1B,GAAGL,IAAI;QACT;QACAF,IAAIQ,IAAI,CAACJ;QACT,IAAIH,YAAYQ,WAAW;YACzBT,IAAIQ,IAAI,IAAIb,qBAA4BM,SAASG,cAAcN,QAAQ;QACzE,CAAC;QACD,OAAOE;IACT,GAAG,EAAE;AACP;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuCC,GACD,gEAAgE;AAChE,OAAO,MAAMU,uBAAuB,CAClCd,QAC+BD,qBAAqBC,OAAO"}

package/lib/utils/getTreeItemValueFromElement.js

@@ -0,0 +1,4 @@
+export const dataTreeItemValueAttrName = 'data-fui-tree-item-value';
+export const getTreeItemValueFromElement = (element)=>{
+    return element.getAttribute(dataTreeItemValueAttrName);
+};

package/lib/utils/getTreeItemValueFromElement.js.map

@@ -0,0 +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,UAAyB;IACnE,OAAOA,QAAQC,YAAY,CAACH;AAC9B,EAAE"}

package/lib/utils/nextTypeAheadElement.js

@@ -1,14 +1,13 @@
 export function nextTypeAheadElement(treeWalker, key) {
-  const keyToLowerCase = key.toLowerCase();
-  const typeAheadFilter = element => {
-    var _element_textContent;
-    return ((_element_textContent = element.textContent) === null || _element_textContent === void 0 ? void 0 : _element_textContent.trim().charAt(0).toLowerCase()) === keyToLowerCase ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
-  };
-  let nextElement = treeWalker.nextElement(typeAheadFilter);
-  if (!nextElement) {
-    treeWalker.currentElement = treeWalker.root;
-    nextElement = treeWalker.nextElement(typeAheadFilter);
-  }
-  return nextElement;
+    const keyToLowerCase = key.toLowerCase();
+    const typeAheadFilter = (element)=>{
+        var _element_textContent;
+        return ((_element_textContent = element.textContent) === null || _element_textContent === void 0 ? void 0 : _element_textContent.trim().charAt(0).toLowerCase()) === keyToLowerCase ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+    };
+    let nextElement = treeWalker.nextElement(typeAheadFilter);
+    if (!nextElement) {
+        treeWalker.currentElement = treeWalker.root;
+        nextElement = treeWalker.nextElement(typeAheadFilter);
+    }
+    return nextElement;
 }
-//# sourceMappingURL=nextTypeAheadElement.js.map

package/lib/utils/nextTypeAheadElement.js.map

@@ -1 +1 @@
-{"version":3,"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","_element_textContent","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"sources":["../../src/utils/nextTypeAheadElement.ts"],"sourcesContent":["import { HTMLElementWalker } from '../hooks/useHTMLElementWalker';\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"],"mappings":"AAEA,OAAO,SAASA,qBAAqBC,UAA6B,EAAEC,GAAW,EAAE;EAC/E,MAAMC,cAAA,GAAiBD,GAAA,CAAIE,WAAW;EACtC,MAAMC,eAAA,GAAmBC,OAAA,IAAyB;QACzCC,oBAAA;IAAP,OAAO,EAAAA,oBAAA,GAAAD,OAAA,CAAQE,WAAW,cAAnBD,oBAAA,uBAAAA,oBAAA,CAAqBE,IAAA,GAAOC,MAAM,CAAC,GAAGN,WAAW,EAAE,MAAKD,cAAA,GAC3DQ,UAAA,CAAWC,aAAa,GACxBD,UAAA,CAAWE,WAAW;EAC5B;EACA,IAAIC,WAAA,GAAcb,UAAA,CAAWa,WAAW,CAACT,eAAA;EACzC,IAAI,CAACS,WAAA,EAAa;IAChBb,UAAA,CAAWc,cAAc,GAAGd,UAAA,CAAWe,IAAI;IAC3CF,WAAA,GAAcb,UAAA,CAAWa,WAAW,CAACT,eAAA;EACvC;EACA,OAAOS,WAAA;AACT"}
+{"version":3,"sources":["nextTypeAheadElement.ts"],"sourcesContent":["import { HTMLElementWalker } from './createHTMLElementWalker';\n\nexport function nextTypeAheadElement(treeWalker: HTMLElementWalker, key: string) {\n  const keyToLowerCase = key.toLowerCase();\n  const typeAheadFilter = (element: HTMLElement) => {\n    return element.textContent?.trim().charAt(0).toLowerCase() === keyToLowerCase\n      ? NodeFilter.FILTER_ACCEPT\n      : NodeFilter.FILTER_SKIP;\n  };\n  let nextElement = treeWalker.nextElement(typeAheadFilter);\n  if (!nextElement) {\n    treeWalker.currentElement = treeWalker.root;\n    nextElement = treeWalker.nextElement(typeAheadFilter);\n  }\n  return nextElement;\n}\n"],"names":["nextTypeAheadElement","treeWalker","key","keyToLowerCase","toLowerCase","typeAheadFilter","element","textContent","trim","charAt","NodeFilter","FILTER_ACCEPT","FILTER_SKIP","nextElement","currentElement","root"],"mappings":"AAEA,OAAO,SAASA,qBAAqBC,UAA6B,EAAEC,GAAW,EAAE;IAC/E,MAAMC,iBAAiBD,IAAIE,WAAW;IACtC,MAAMC,kBAAkB,CAACC,UAAyB;YACzCA;QAAP,OAAOA,CAAAA,CAAAA,uBAAAA,QAAQC,WAAW,cAAnBD,kCAAAA,KAAAA,IAAAA,qBAAqBE,OAAOC,MAAM,CAAC,GAAGL,WAAW,EAAE,AAAD,MAAMD,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,CAAC;IACD,OAAOQ;AACT,CAAC"}

package/lib/utils/normalizeOpenItems.js

@@ -1,7 +1,8 @@
 export function normalizeOpenItems(openSubtrees, options) {
-  if (!openSubtrees) {
-    return (options === null || options === void 0 ? void 0 : options.keepUndefined) ? undefined : [];
-  }
-  return Array.isArray(openSubtrees) ? openSubtrees : [openSubtrees];
+    if (!openSubtrees) {
+        return (options === null || options === void 0 ? void 0 : options.keepUndefined) ? undefined : [];
+    }
+    return Array.isArray(openSubtrees) ? openSubtrees : [
+        openSubtrees
+    ];
 }
-//# sourceMappingURL=normalizeOpenItems.js.map

package/lib/utils/normalizeOpenItems.js.map

@@ -1 +1 @@
-{"version":3,"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"sources":["../../src/utils/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"],"mappings":"AAcA,OAAO,SAASA,mBACdC,YAAgC,EAChCC,OAEC,EACqB;EACtB,IAAI,CAACD,YAAA,EAAc;IACjB,OAAO,CAAAC,OAAA,aAAAA,OAAA,uBAAAA,OAAA,CAASC,aAAa,IAAGC,SAAA,GAAY,EAAE;EAChD;EACA,OAAOC,KAAA,CAAMC,OAAO,CAACL,YAAA,IAAgBA,YAAA,GAAe,CAACA,YAAA,CAAa;AACpE"}
+{"version":3,"sources":["normalizeOpenItems.ts"],"sourcesContent":["export function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: false;\n  },\n): string[];\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined: true;\n  },\n): string[] | undefined;\n\nexport function normalizeOpenItems(\n  openSubtrees?: string | string[],\n  options?: {\n    keepUndefined?: boolean;\n  },\n): string[] | undefined {\n  if (!openSubtrees) {\n    return options?.keepUndefined ? undefined : [];\n  }\n  return Array.isArray(openSubtrees) ? openSubtrees : [openSubtrees];\n}\n"],"names":["normalizeOpenItems","openSubtrees","options","keepUndefined","undefined","Array","isArray"],"mappings":"AAcA,OAAO,SAASA,mBACdC,YAAgC,EAChCC,OAEC,EACqB;IACtB,IAAI,CAACD,cAAc;QACjB,OAAOC,CAAAA,oBAAAA,qBAAAA,KAAAA,IAAAA,QAASC,aAAa,AAAD,IAAIC,YAAY,EAAE;IAChD,CAAC;IACD,OAAOC,MAAMC,OAAO,CAACL,gBAAgBA,eAAe;QAACA;KAAa;AACpE,CAAC"}

package/lib/utils/tokens.js

@@ -1,19 +1,19 @@
-import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home } from '@fluentui/keyboard-keys';
+import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';
 export const treeItemLevelToken = '--fluent-TreeItem--level';
 export const treeAvatarSize = {
-  medium: 32,
-  small: 24
+    medium: 32,
+    small: 24
 };
 export const treeDataTypes = {
-  arrowLeft: ArrowLeft,
-  arrowRight: ArrowRight,
-  enter: 'Enter',
-  click: 'Click',
-  expandIconClick: 'ExpandIconClick',
-  end: End,
-  home: Home,
-  arrowUp: ArrowUp,
-  arrowDown: ArrowDown,
-  typeAhead: 'TypeAhead'
+    ArrowLeft,
+    ArrowRight,
+    Enter,
+    Click: 'Click',
+    ExpandIconClick: 'ExpandIconClick',
+    End,
+    Home,
+    ArrowUp,
+    ArrowDown,
+    TypeAhead: 'TypeAhead',
+    Change: 'Change'
 };
-//# sourceMappingURL=tokens.js.map

package/lib/utils/tokens.js.map

@@ -1 +1 @@
-{"version":3,"names":["ArrowDown","ArrowLeft","ArrowRight","ArrowUp","End","Home","treeItemLevelToken","treeAvatarSize","medium","small","treeDataTypes","arrowLeft","arrowRight","enter","click","expandIconClick","end","home","arrowUp","arrowDown","typeAhead"],"sources":["../../src/utils/tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home } from '@fluentui/keyboard-keys';\nimport { 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 Uncapitalize<TreeOpenChangeData['type'] | TreeNavigationData_unstable['type']>]: Capitalize<K>;\n} = {\n  arrowLeft: ArrowLeft,\n  arrowRight: ArrowRight,\n  enter: 'Enter',\n  click: 'Click',\n  expandIconClick: 'ExpandIconClick',\n  end: End,\n  home: Home,\n  arrowUp: ArrowUp,\n  arrowDown: ArrowDown,\n  typeAhead: 'TypeAhead',\n};\n"],"mappings":"AAAA,SAASA,SAAS,EAAEC,SAAS,EAAEC,UAAU,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,QAAQ;AAGrE,OAAO,MAAMC,kBAAA,GAAqB;AAElC,OAAO,MAAMC,cAAA,GAAiB;EAC5BC,MAAA,EAAQ;EACRC,KAAA,EAAO;AACT;AAEA,OAAO,MAAMC,aAAA,GAET;EACFC,SAAA,EAAWV,SAAA;EACXW,UAAA,EAAYV,UAAA;EACZW,KAAA,EAAO;EACPC,KAAA,EAAO;EACPC,eAAA,EAAiB;EACjBC,GAAA,EAAKZ,GAAA;EACLa,IAAA,EAAMZ,IAAA;EACNa,OAAA,EAASf,OAAA;EACTgB,SAAA,EAAWnB,SAAA;EACXoB,SAAA,EAAW;AACb"}
+{"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"}

package/lib/utils/treeItemFilter.js

@@ -1,4 +1,3 @@
-export const treeItemFilter = element => {
-  return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
+export const treeItemFilter = (element)=>{
+    return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
 };
-//# sourceMappingURL=treeItemFilter.js.map

package/lib/utils/treeItemFilter.js.map

@@ -1 +1 @@
-{"version":3,"names":["treeItemFilter","element","getAttribute","NodeFilter","FILTER_ACCEPT","FILTER_SKIP"],"sources":["../../src/utils/treeItemFilter.ts"],"sourcesContent":["export const treeItemFilter = (element: HTMLElement) => {\n  return element.getAttribute('role') === 'treeitem' ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;\n};\n"],"mappings":"AAAA,OAAO,MAAMA,cAAA,GAAkBC,OAAA,IAAyB;EACtD,OAAOA,OAAA,CAAQC,YAAY,CAAC,YAAY,aAAaC,UAAA,CAAWC,aAAa,GAAGD,UAAA,CAAWE,WAAW;AACxG"}
+{"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,UAAyB;IACtD,OAAOA,QAAQC,YAAY,CAAC,YAAY,aAAaC,WAAWC,aAAa,GAAGD,WAAWE,WAAW;AACxG,EAAE"}

package/lib-commonjs/FlatTree.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
+_exportStar(require("./components/FlatTree/index"), exports);

package/lib-commonjs/FlatTree.js.map

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

package/lib-commonjs/Tree.js

@@ -4,6 +4,3 @@ Object.defineProperty(exports, "__esModule", {
 });
 const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
 _exportStar(require("./components/Tree/index"), exports);
- //# sourceMappingURL=Tree.js.map
-
-//# sourceMappingURL=Tree.js.map

package/lib-commonjs/Tree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../lib/Tree.js"],"sourcesContent":["export * from './components/Tree/index';\n//# sourceMappingURL=Tree.js.map"],"names":[],"mappings":";;;;;oBAAc;CACd,gCAAgC"}
+{"version":3,"sources":["Tree.js"],"sourcesContent":["export * from './components/Tree/index';\n"],"names":[],"mappings":";;;;;oBAAc"}