@fluentui/react-tree 9.0.0-beta.25 → 9.0.0-beta.27

package/lib/utils/ImmutableMap.js

@@ -0,0 +1,41 @@
+const emptyImmutableMap = createImmutableMap();
+/**
+ * properly creates an ImmutableMap instance from an iterable
+ */ function createImmutableMap(iterable) {
+    const internalMap = new Map(iterable);
+    return dangerouslyCreateImmutableMap(internalMap);
+}
+/**
+ * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,
+ * @param internalMap - a set that is used internally to store values.
+ */ function dangerouslyCreateImmutableMap(internalMap) {
+    return {
+        size: internalMap.size,
+        set: (key, value)=>{
+            const nextSet = new Map(internalMap);
+            nextSet.set(key, value);
+            return dangerouslyCreateImmutableMap(nextSet);
+        },
+        get: (key)=>internalMap.get(key),
+        clear: ()=>emptyImmutableMap,
+        delete (value) {
+            const nextSet = new Map(internalMap);
+            nextSet.delete(value);
+            return dangerouslyCreateImmutableMap(nextSet);
+        },
+        has: (value)=>internalMap.has(value),
+        [Symbol.iterator]: ()=>internalMap[Symbol.iterator](),
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        dangerouslyGetInternalMap_unstable: ()=>internalMap
+    };
+}
+function isImmutableMap(value) {
+    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;
+}
+export const ImmutableMap = {
+    empty: emptyImmutableMap,
+    create: createImmutableMap,
+    isImmutableMap,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap
+};

package/lib/utils/ImmutableMap.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["ImmutableMap.ts"],"sourcesContent":["export interface ImmutableMap<Key, Value> {\n  clear(): ImmutableMap<Key, Value>;\n  delete(key: Key): ImmutableMap<Key, Value>;\n  /**\n   * Returns a specified element from the Map object. If the value that is associated to the provided key is an object, then you will get a reference to that object and any change made to that object will effectively modify it inside the Map.\n   * @returns Returns the element associated with the specified key. If no element is associated with the specified key, undefined is returned.\n   */\n  get(key: Key): Value | undefined;\n  /**\n   * @returns boolean indicating whether an element with the specified key exists or not.\n   */\n  has(key: Key): boolean;\n  /**\n   * Adds a new element with a specified key and value to the Map. If an element with the same key already exists, the element will be updated.\n   */\n  set(key: Key, value: Value): ImmutableMap<Key, Value>;\n  /**\n   * @returns the number of elements in the Map.\n   */\n  readonly size: number;\n  /** Iterates over entries in the Map. */\n  [Symbol.iterator](): IterableIterator<[Key, Value]>;\n  /**\n   * @internal\n   * Exposes the internal map used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalMap_unstable(): Map<Key, Value>;\n}\n\nconst emptyImmutableMap = createImmutableMap<never, never>();\n\n/**\n * properly creates an ImmutableMap instance from an iterable\n */\nfunction createImmutableMap<Key, Value>(iterable?: Iterable<[Key, Value]>): ImmutableMap<Key, Value> {\n  const internalMap = new Map(iterable);\n  return dangerouslyCreateImmutableMap(internalMap);\n}\n/**\n * Avoid using *dangerouslyCreateImmutableMap*, since this method will expose internally used set, use  createImmutableMap instead,\n * @param internalMap - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableMap<Key, Value>(internalMap: Map<Key, Value>): ImmutableMap<Key, Value> {\n  return {\n    size: internalMap.size,\n    set: (key, value) => {\n      const nextSet = new Map(internalMap);\n      nextSet.set(key, value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    get: key => internalMap.get(key),\n    clear: () => emptyImmutableMap,\n    delete(value) {\n      const nextSet = new Map(internalMap);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableMap(nextSet);\n    },\n    has: value => internalMap.has(value),\n    [Symbol.iterator]: () => internalMap[Symbol.iterator](),\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalMap_unstable: () => internalMap,\n  };\n}\n\nfunction isImmutableMap<Key, Value>(value: unknown): value is ImmutableMap<Key, Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalMap_unstable' in value;\n}\n\nexport const ImmutableMap = {\n  empty: emptyImmutableMap,\n  create: createImmutableMap,\n  isImmutableMap,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableMap,\n};\n"],"names":["emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","ImmutableMap","empty","create","dangerouslyCreate_unstable"],"mappings":"AA+BA,MAAMA,oBAAoBC;AAE1B;;CAEC,GACD,SAASA,mBAA+BC,QAAiC,EAA4B;IACnG,MAAMC,cAAc,IAAIC,IAAIF;IAC5B,OAAOG,8BAA8BF;AACvC;AACA;;;CAGC,GACD,SAASE,8BAA0CF,WAA4B,EAA4B;IACzG,OAAO;QACLG,MAAMH,YAAYG,IAAI;QACtBC,KAAK,CAACC,KAAKC,QAAU;YACnB,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQH,GAAG,CAACC,KAAKC;YACjB,OAAOJ,8BAA8BK;QACvC;QACAC,KAAKH,CAAAA,MAAOL,YAAYQ,GAAG,CAACH;QAC5BI,OAAO,IAAMZ;QACba,QAAOJ,KAAK,EAAE;YACZ,MAAMC,UAAU,IAAIN,IAAID;YACxBO,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAKL,CAAAA,QAASN,YAAYW,GAAG,CAACL;QAC9B,CAACM,OAAOC,QAAQ,CAAC,EAAE,IAAMb,WAAW,CAACY,OAAOC,QAAQ,CAAC;QACrD,gEAAgE;QAChEC,oCAAoC,IAAMd;IAC5C;AACF;AAEA,SAASe,eAA2BT,KAAc,EAAqC;IACrF,OAAO,OAAOA,UAAU,YAAYA,UAAU,IAAI,IAAI,wCAAwCA;AAChG;AAEA,OAAO,MAAMU,eAAe;IAC1BC,OAAOpB;IACPqB,QAAQpB;IACRiB;IACA,gEAAgE;IAChEI,4BAA4BjB;AAC9B,EAAE"}

package/lib/utils/ImmutableSet.js

@@ -25,9 +25,12 @@ const emptyImmutableSet = createImmutableSet();
             return internalSet[Symbol.iterator]();
         },
         // eslint-disable-next-line @typescript-eslint/naming-convention
-        dangerousGetInternalSet_unstable: ()=>internalSet
+        dangerouslyGetInternalSet_unstable: ()=>internalSet
     };
 }
+function isImmutableSet(value) {
+    return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;
+}
 /**
  * properly creates an ImmutableSet instance from an iterable
  */ function createImmutableSet(iterable) {
@@ -37,5 +40,7 @@ const emptyImmutableSet = createImmutableSet();
 export const ImmutableSet = {
     empty: emptyImmutableSet,
     create: createImmutableSet,
-    dangerouslyCreate: dangerouslyCreateImmutableSet
+    isImmutableSet,
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet
 };

package/lib/utils/ImmutableSet.js.map

@@ -1 +1 @@
-{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["export interface ImmutableSet<Value> {\n  /**\n   * The number of (unique) elements in a ImmutableSet.\n   */\n  readonly size: number;\n  /**\n   * Creates a new ImmutableSet containing all previous element plus the one provided as argument\n   * @param value - new value to be included in the new ImmutableSet instance\n   */\n  add(value: Value): ImmutableSet<Value>;\n  /**\n   * Returns a reference to ImmutableSet.emptySet\n   */\n  clear(): ImmutableSet<Value>;\n  /**\n   * Creates a new ImmutableSet with the original items and removes a specified value from the new ImmutableSet.\n   */\n  delete(value: Value): ImmutableSet<Value>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the ImmutableSet or not.\n   */\n  has(value: Value): boolean;\n  /** Iterates over values in the ImmutableSet. */\n  [Symbol.iterator](): IterableIterator<Value>;\n  /**\n   * @internal\n   * Exposes the internal set used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerousGetInternalSet_unstable(): Set<Value>;\n}\n\nconst emptyImmutableSet = createImmutableSet<never>();\n\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableSet<Value>(internalSet: Set<Value>): ImmutableSet<Value> {\n  return {\n    size: internalSet.size,\n    add(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.add(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    clear() {\n      return emptyImmutableSet;\n    },\n    delete(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    has(value) {\n      return internalSet.has(value);\n    },\n    [Symbol.iterator]() {\n      return internalSet[Symbol.iterator]();\n    },\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerousGetInternalSet_unstable: () => internalSet,\n  };\n}\n\n/**\n * properly creates an ImmutableSet instance from an iterable\n */\nfunction createImmutableSet<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n  const internalSet = new Set(iterable);\n  return dangerouslyCreateImmutableSet(internalSet);\n}\n\nexport const ImmutableSet = {\n  empty: emptyImmutableSet,\n  create: createImmutableSet,\n  dangerouslyCreate: dangerouslyCreateImmutableSet,\n};\n"],"names":["emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerousGetInternalSet_unstable","iterable","ImmutableSet","empty","create","dangerouslyCreate"],"mappings":"AAiCA,MAAMA,oBAAoBC;AAE1B;;;CAGC,GACD,SAASC,8BAAqCC,WAAuB,EAAuB;IAC1F,OAAO;QACLC,MAAMD,YAAYC,IAAI;QACtBC,KAAIC,KAAK,EAAE;YACT,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACvC;QACAE,SAAQ;YACN,OAAOT;QACT;QACAU,QAAOJ,KAAK,EAAE;YACZ,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAIL,KAAK,EAAE;YACT,OAAOH,YAAYQ,GAAG,CAACL;QACzB;QACA,CAACM,OAAOC,QAAQ,CAAC,IAAG;YAClB,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACrC;QACA,gEAAgE;QAChEC,kCAAkC,IAAMX;IAC1C;AACF;AAEA;;CAEC,GACD,SAASF,mBAA0Bc,QAA0B,EAAuB;IAClF,MAAMZ,cAAc,IAAIK,IAAIO;IAC5B,OAAOb,8BAA8BC;AACvC;AAEA,OAAO,MAAMa,eAAe;IAC1BC,OAAOjB;IACPkB,QAAQjB;IACRkB,mBAAmBjB;AACrB,EAAE"}
+{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["export interface ImmutableSet<Value> {\n  /**\n   * The number of (unique) elements in a ImmutableSet.\n   */\n  readonly size: number;\n  /**\n   * Creates a new ImmutableSet containing all previous element plus the one provided as argument\n   * @param value - new value to be included in the new ImmutableSet instance\n   */\n  add(value: Value): ImmutableSet<Value>;\n  /**\n   * Returns a reference to ImmutableSet.emptySet\n   */\n  clear(): ImmutableSet<Value>;\n  /**\n   * Creates a new ImmutableSet with the original items and removes a specified value from the new ImmutableSet.\n   */\n  delete(value: Value): ImmutableSet<Value>;\n  /**\n   * @returns a boolean indicating whether an element with the specified value exists in the ImmutableSet or not.\n   */\n  has(value: Value): boolean;\n  /** Iterates over values in the ImmutableSet. */\n  [Symbol.iterator](): IterableIterator<Value>;\n  /**\n   * @internal\n   * Exposes the internal set used to store values.\n   * This is an internal API and should not be used directly.\n   */\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyGetInternalSet_unstable(): Set<Value>;\n}\n\nconst emptyImmutableSet = createImmutableSet<never>();\n\n/**\n * Avoid using *dangerouslyCreateImmutableSet*, since this method will expose internally used set, use  createImmutableSet instead,\n * @param internalSet - a set that is used internally to store values.\n */\nfunction dangerouslyCreateImmutableSet<Value>(internalSet: Set<Value>): ImmutableSet<Value> {\n  return {\n    size: internalSet.size,\n    add(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.add(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    clear() {\n      return emptyImmutableSet;\n    },\n    delete(value) {\n      const nextSet = new Set(internalSet);\n      nextSet.delete(value);\n      return dangerouslyCreateImmutableSet(nextSet);\n    },\n    has(value) {\n      return internalSet.has(value);\n    },\n    [Symbol.iterator]() {\n      return internalSet[Symbol.iterator]();\n    },\n    // eslint-disable-next-line @typescript-eslint/naming-convention\n    dangerouslyGetInternalSet_unstable: () => internalSet,\n  };\n}\n\nfunction isImmutableSet<Value>(value: unknown): value is ImmutableSet<Value> {\n  return typeof value === 'object' && value !== null && 'dangerouslyGetInternalSet_unstable' in value;\n}\n\n/**\n * properly creates an ImmutableSet instance from an iterable\n */\nfunction createImmutableSet<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n  const internalSet = new Set(iterable);\n  return dangerouslyCreateImmutableSet(internalSet);\n}\n\nexport const ImmutableSet = {\n  empty: emptyImmutableSet,\n  create: createImmutableSet,\n  isImmutableSet,\n  // eslint-disable-next-line @typescript-eslint/naming-convention\n  dangerouslyCreate_unstable: dangerouslyCreateImmutableSet,\n};\n"],"names":["emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","ImmutableSet","empty","create","dangerouslyCreate_unstable"],"mappings":"AAiCA,MAAMA,oBAAoBC;AAE1B;;;CAGC,GACD,SAASC,8BAAqCC,WAAuB,EAAuB;IAC1F,OAAO;QACLC,MAAMD,YAAYC,IAAI;QACtBC,KAAIC,KAAK,EAAE;YACT,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACvC;QACAE,SAAQ;YACN,OAAOT;QACT;QACAU,QAAOJ,KAAK,EAAE;YACZ,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAIL,KAAK,EAAE;YACT,OAAOH,YAAYQ,GAAG,CAACL;QACzB;QACA,CAACM,OAAOC,QAAQ,CAAC,IAAG;YAClB,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACrC;QACA,gEAAgE;QAChEC,oCAAoC,IAAMX;IAC5C;AACF;AAEA,SAASY,eAAsBT,KAAc,EAAgC;IAC3E,OAAO,OAAOA,UAAU,YAAYA,UAAU,IAAI,IAAI,wCAAwCA;AAChG;AAEA;;CAEC,GACD,SAASL,mBAA0Be,QAA0B,EAAuB;IAClF,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACvC;AAEA,OAAO,MAAMc,eAAe;IAC1BC,OAAOlB;IACPmB,QAAQlB;IACRc;IACA,gEAAgE;IAChEK,4BAA4BlB;AAC9B,EAAE"}

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/createHeadlessTree.js

@@ -0,0 +1,165 @@
+/**
+ * creates a list of virtual tree items
+ * and provides a map to access each item by id
+ */ export function createHeadlessTree(virtualTreeItemProps) {
+    const root = createHeadlessTreeRootItem();
+    const itemsPerValue = new Map([
+        [
+            root.value,
+            root
+        ]
+    ]);
+    const items = [];
+    for(let index = 0; index < virtualTreeItemProps.length; index++){
+        const { parentValue =virtualTreeRootId , ...treeItemProps } = virtualTreeItemProps[index];
+        const nextItemProps = virtualTreeItemProps[index + 1];
+        const currentParent = itemsPerValue.get(parentValue);
+        if (!currentParent) {
+            if (process.env.NODE_ENV === 'development') {
+                // eslint-disable-next-line no-console
+                console.error(`useHeadlessTree: item ${virtualTreeItemProps[index].value} is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized`);
+            }
+            break;
+        }
+        var _treeItemProps_itemType;
+        const itemType = (_treeItemProps_itemType = treeItemProps.itemType) !== null && _treeItemProps_itemType !== void 0 ? _treeItemProps_itemType : treeItemProps.value === undefined || (nextItemProps === null || nextItemProps === void 0 ? void 0 : nextItemProps.parentValue) !== treeItemProps.value ? 'leaf' : 'branch';
+        var _currentParent_level;
+        const currentLevel = ((_currentParent_level = currentParent.level) !== null && _currentParent_level !== void 0 ? _currentParent_level : 0) + 1;
+        const virtualTreeItem = {
+            value: treeItemProps.value,
+            getTreeItemProps: ()=>({
+                    ...treeItemProps,
+                    'aria-level': currentLevel,
+                    'aria-posinset': currentChildrenSize,
+                    'aria-setsize': currentParent.childrenValues.length,
+                    itemType
+                }),
+            level: currentLevel,
+            parentValue,
+            childrenValues: [],
+            index: -1
+        };
+        const currentChildrenSize = currentParent.childrenValues.push(virtualTreeItem.value);
+        itemsPerValue.set(virtualTreeItem.value, virtualTreeItem);
+        items.push(virtualTreeItem);
+    }
+    var _itemsPerValue_get_parentValue, _itemsPerValue_get;
+    const virtualTreeItems = {
+        root,
+        size: items.length,
+        getByIndex: (index)=>items[index],
+        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),
+        subtree: (key)=>HeadlessTreeSubtreeGenerator(key, virtualTreeItems),
+        children: (key)=>HeadlessTreeChildrenGenerator(key, virtualTreeItems),
+        ancestors: (key)=>HeadlessTreeAncestorsGenerator(key, virtualTreeItems),
+        visibleItems: (openItems)=>HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems)
+    };
+    return virtualTreeItems;
+}
+export const virtualTreeRootId = '__fuiHeadlessTreeRoot';
+function createHeadlessTreeRootItem() {
+    return {
+        parentValue: undefined,
+        value: virtualTreeRootId,
+        getTreeItemProps: ()=>{
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.error('useHeadlessTree: internal error, trying to access treeitem props from invalid root element');
+            }
+            return {
+                id: virtualTreeRootId,
+                value: virtualTreeRootId,
+                '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('useHeadlessTree: 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 [];
+    }
+    let counter = item.childrenValues.length;
+    let index = item.index;
+    while(counter > 0){
+        const children = virtualTreeItems.getByIndex(++index);
+        yield children;
+        counter += children.childrenValues.length - 1;
+    }
+}
+/**
+ * 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) {
+    for(let index = 0, visibleIndex = 0; index < virtualTreeItems.size; index++){
+        const item = virtualTreeItems.getByIndex(index);
+        if (isItemVisible(item, openItems, virtualTreeItems)) {
+            item.index = visibleIndex++;
+            yield item;
+        } else {
+            // Jump the amount of children the current item has, since those items will also be hidden
+            index += item.childrenValues.length;
+        }
+    }
+}
+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  index: number;\n  level: number;\n  childrenValues: TreeItemValue[];\n  value: TreeItemValue;\n  parentValue: TreeItemValue | undefined;\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  size: number;\n  root: HeadlessTreeItem<HeadlessTreeItemProps>;\n  get(key: TreeItemValue): HeadlessTreeItem<Props> | undefined;\n  getParent(key: TreeItemValue): HeadlessTreeItem<Props>;\n  getByIndex(index: number): HeadlessTreeItem<Props>;\n  subtree(key: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n  children(key: TreeItemValue): IterableIterator<HeadlessTreeItem<Props>>;\n  visibleItems(openItems: ImmutableSet<TreeItemValue>): IterableIterator<HeadlessTreeItem<Props>>;\n  ancestors(key: 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  virtualTreeItemProps: Props[],\n): HeadlessTree<Props> {\n  const root = createHeadlessTreeRootItem();\n  const itemsPerValue = new Map<TreeItemValue, HeadlessTreeItem<HeadlessTreeItemProps>>([[root.value, root]]);\n  const items: HeadlessTreeItem<HeadlessTreeItemProps>[] = [];\n\n  for (let index = 0; index < virtualTreeItemProps.length; index++) {\n    const { parentValue = virtualTreeRootId, ...treeItemProps } = virtualTreeItemProps[index];\n\n    const nextItemProps: Props | undefined = virtualTreeItemProps[index + 1];\n    const currentParent = itemsPerValue.get(parentValue);\n    if (!currentParent) {\n      if (process.env.NODE_ENV === 'development') {\n        // eslint-disable-next-line no-console\n        console.error(\n          `useHeadlessTree: item ${virtualTreeItemProps[index].value} is wrongly positioned, did you properly ordered provided item props? make sure provided items are organized`,\n        );\n      }\n      break;\n    }\n    const itemType =\n      treeItemProps.itemType ??\n      (treeItemProps.value === undefined || nextItemProps?.parentValue !== treeItemProps.value ? 'leaf' : 'branch');\n    const currentLevel = (currentParent.level ?? 0) + 1;\n\n    const virtualTreeItem: HeadlessTreeItem<HeadlessTreeItemProps> = {\n      value: treeItemProps.value,\n      getTreeItemProps: () => ({\n        ...treeItemProps,\n        'aria-level': currentLevel,\n        'aria-posinset': currentChildrenSize,\n        'aria-setsize': currentParent.childrenValues.length,\n        itemType,\n      }),\n      level: currentLevel,\n      parentValue,\n      childrenValues: [],\n      index: -1,\n    };\n    const currentChildrenSize = currentParent.childrenValues.push(virtualTreeItem.value);\n    itemsPerValue.set(virtualTreeItem.value, virtualTreeItem);\n    items.push(virtualTreeItem);\n  }\n\n  const virtualTreeItems: HeadlessTree<HeadlessTreeItemProps> = {\n    root,\n    size: items.length,\n    getByIndex: index => items[index],\n    getParent: key => itemsPerValue.get(itemsPerValue.get(key)?.parentValue ?? root.value) ?? root,\n    get: key => itemsPerValue.get(key),\n    subtree: key => HeadlessTreeSubtreeGenerator(key, virtualTreeItems),\n    children: key => HeadlessTreeChildrenGenerator(key, virtualTreeItems),\n    ancestors: key => HeadlessTreeAncestorsGenerator(key, virtualTreeItems),\n    visibleItems: openItems => HeadlessTreeVisibleItemsGenerator(openItems, virtualTreeItems),\n  };\n\n  return virtualTreeItems as HeadlessTree<Props>;\n}\n\nexport const virtualTreeRootId = '__fuiHeadlessTreeRoot';\n\nfunction createHeadlessTreeRootItem(): HeadlessTreeItem<HeadlessTreeItemProps> {\n  return {\n    parentValue: undefined,\n    value: virtualTreeRootId,\n    getTreeItemProps: () => {\n      if (process.env.NODE_ENV !== 'production') {\n        // eslint-disable-next-line no-console\n        console.error('useHeadlessTree: internal error, trying to access treeitem props from invalid root element');\n      }\n      return {\n        id: virtualTreeRootId,\n        value: virtualTreeRootId,\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('useHeadlessTree: 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) {\n  const item = virtualTreeItems.get(key);\n  if (!item || item.childrenValues.length === 0) {\n    return [];\n  }\n  let counter = item.childrenValues.length;\n  let index = item.index;\n  while (counter > 0) {\n    const children = virtualTreeItems.getByIndex(++index);\n    yield children;\n    counter += children.childrenValues.length - 1;\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) {\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) {\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) {\n  for (let index = 0, visibleIndex = 0; index < virtualTreeItems.size; index++) {\n    const item = virtualTreeItems.getByIndex(index) as HeadlessTreeItem<Props>;\n    if (isItemVisible(item, openItems, virtualTreeItems)) {\n      item.index = visibleIndex++;\n      yield item;\n    } else {\n      // Jump the amount of children the current item has, since those items will also be hidden\n      index += item.childrenValues.length;\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","virtualTreeItemProps","root","createHeadlessTreeRootItem","itemsPerValue","Map","value","items","index","length","parentValue","virtualTreeRootId","treeItemProps","nextItemProps","currentParent","get","process","env","NODE_ENV","console","error","itemType","undefined","currentLevel","level","virtualTreeItem","getTreeItemProps","currentChildrenSize","childrenValues","push","set","virtualTreeItems","size","getByIndex","getParent","key","subtree","HeadlessTreeSubtreeGenerator","children","HeadlessTreeChildrenGenerator","ancestors","HeadlessTreeAncestorsGenerator","visibleItems","openItems","HeadlessTreeVisibleItemsGenerator","id","item","counter","childValue","parent","visibleIndex","isItemVisible","has"],"mappings":"AAsCA;;;CAGC,GACD,OAAO,SAASA,mBACdC,oBAA6B,EACR;IACrB,MAAMC,OAAOC;IACb,MAAMC,gBAAgB,IAAIC,IAA4D;QAAC;YAACH,KAAKI,KAAK;YAAEJ;SAAK;KAAC;IAC1G,MAAMK,QAAmD,EAAE;IAE3D,IAAK,IAAIC,QAAQ,GAAGA,QAAQP,qBAAqBQ,MAAM,EAAED,QAAS;QAChE,MAAM,EAAEE,aAAcC,kBAAiB,EAAE,GAAGC,eAAe,GAAGX,oBAAoB,CAACO,MAAM;QAEzF,MAAMK,gBAAmCZ,oBAAoB,CAACO,QAAQ,EAAE;QACxE,MAAMM,gBAAgBV,cAAcW,GAAG,CAACL;QACxC,IAAI,CAACI,eAAe;YAClB,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,eAAe;gBAC1C,sCAAsC;gBACtCC,QAAQC,KAAK,CACX,CAAC,sBAAsB,EAAEnB,oBAAoB,CAACO,MAAM,CAACF,KAAK,CAAC,4GAA4G,CAAC;YAE5K,CAAC;YACD,KAAM;QACR,CAAC;YAECM;QADF,MAAMS,WACJT,CAAAA,0BAAAA,cAAcS,QAAQ,cAAtBT,qCAAAA,0BACCA,cAAcN,KAAK,KAAKgB,aAAaT,CAAAA,0BAAAA,2BAAAA,KAAAA,IAAAA,cAAeH,WAAW,AAAD,MAAME,cAAcN,KAAK,GAAG,SAAS,QAAQ,AAAC;YACzFQ;QAAtB,MAAMS,eAAe,AAACT,CAAAA,CAAAA,uBAAAA,cAAcU,KAAK,cAAnBV,kCAAAA,uBAAuB,CAAC,AAAD,IAAK;QAElD,MAAMW,kBAA2D;YAC/DnB,OAAOM,cAAcN,KAAK;YAC1BoB,kBAAkB,IAAO,CAAA;oBACvB,GAAGd,aAAa;oBAChB,cAAcW;oBACd,iBAAiBI;oBACjB,gBAAgBb,cAAcc,cAAc,CAACnB,MAAM;oBACnDY;gBACF,CAAA;YACAG,OAAOD;YACPb;YACAkB,gBAAgB,EAAE;YAClBpB,OAAO,CAAC;QACV;QACA,MAAMmB,sBAAsBb,cAAcc,cAAc,CAACC,IAAI,CAACJ,gBAAgBnB,KAAK;QACnFF,cAAc0B,GAAG,CAACL,gBAAgBnB,KAAK,EAAEmB;QACzClB,MAAMsB,IAAI,CAACJ;IACb;QAMsCrB,gCAAlBA;IAJpB,MAAM2B,mBAAwD;QAC5D7B;QACA8B,MAAMzB,MAAME,MAAM;QAClBwB,YAAYzB,CAAAA,QAASD,KAAK,CAACC,MAAM;QACjC0B,WAAWC,CAAAA;gBAAyB/B;YAAlBA,OAAAA,CAAAA,qBAAAA,cAAcW,GAAG,CAACX,CAAAA,iCAAAA,CAAAA,sBAAAA,cAAcW,GAAG,CAACoB,kBAAlB/B,iCAAAA,KAAAA,IAAAA,oBAAwBM,WAAW,cAAnCN,4CAAAA,iCAAuCF,KAAKI,KAAK,eAAnEF,gCAAAA,qBAAwEF,IAAI;;QAC9Fa,KAAKoB,CAAAA,MAAO/B,cAAcW,GAAG,CAACoB;QAC9BC,SAASD,CAAAA,MAAOE,6BAA6BF,KAAKJ;QAClDO,UAAUH,CAAAA,MAAOI,8BAA8BJ,KAAKJ;QACpDS,WAAWL,CAAAA,MAAOM,+BAA+BN,KAAKJ;QACtDW,cAAcC,CAAAA,YAAaC,kCAAkCD,WAAWZ;IAC1E;IAEA,OAAOA;AACT,CAAC;AAED,OAAO,MAAMpB,oBAAoB,wBAAwB;AAEzD,SAASR,6BAAsE;IAC7E,OAAO;QACLO,aAAaY;QACbhB,OAAOK;QACPe,kBAAkB,IAAM;YACtB,IAAIV,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;gBACzC,sCAAsC;gBACtCC,QAAQC,KAAK,CAAC;YAChB,CAAC;YACD,OAAO;gBACLyB,IAAIlC;gBACJL,OAAOK;gBACP,gBAAgB,CAAC;gBACjB,cAAc,CAAC;gBACf,iBAAiB,CAAC;gBAClBU,UAAU;YACZ;QACF;QACAO,gBAAgB,EAAE;QAClB,IAAIpB,SAAQ;YACV,IAAIQ,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,UAAUa,6BACRF,GAAkB,EAClBJ,gBAAqC,EACrC;IACA,MAAMe,OAAOf,iBAAiBhB,GAAG,CAACoB;IAClC,IAAI,CAACW,QAAQA,KAAKlB,cAAc,CAACnB,MAAM,KAAK,GAAG;QAC7C,OAAO,EAAE;IACX,CAAC;IACD,IAAIsC,UAAUD,KAAKlB,cAAc,CAACnB,MAAM;IACxC,IAAID,QAAQsC,KAAKtC,KAAK;IACtB,MAAOuC,UAAU,EAAG;QAClB,MAAMT,WAAWP,iBAAiBE,UAAU,CAAC,EAAEzB;QAC/C,MAAM8B;QACNS,WAAWT,SAASV,cAAc,CAACnB,MAAM,GAAG;IAC9C;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAU8B,8BACRJ,GAAkB,EAClBJ,gBAAqC,EACrC;IACA,MAAMe,OAAOf,iBAAiBhB,GAAG,CAACoB;IAClC,IAAI,CAACW,QAAQA,KAAKlB,cAAc,CAACnB,MAAM,KAAK,GAAG;QAC7C;IACF,CAAC;IACD,KAAK,MAAMuC,cAAcF,KAAKlB,cAAc,CAAE;QAC5C,MAAMG,iBAAiBhB,GAAG,CAACiC;IAC7B;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUP,+BACRN,GAAkB,EAClBJ,gBAAqC,EACrC;IACA,IAAIkB,SAASlB,iBAAiBG,SAAS,CAACC;IACxC,MAAOc,WAAWlB,iBAAiB7B,IAAI,CAAE;QACvC,MAAM+C;QACNA,SAASlB,iBAAiBG,SAAS,CAACe,OAAO3C,KAAK;IAClD;AACF;AAEA;;;CAGC,GACD,gEAAgE;AAChE,UAAUsC,kCACRD,SAAsC,EACtCZ,gBAAqC,EACrC;IACA,IAAK,IAAIvB,QAAQ,GAAG0C,eAAe,GAAG1C,QAAQuB,iBAAiBC,IAAI,EAAExB,QAAS;QAC5E,MAAMsC,OAAOf,iBAAiBE,UAAU,CAACzB;QACzC,IAAI2C,cAAcL,MAAMH,WAAWZ,mBAAmB;YACpDe,KAAKtC,KAAK,GAAG0C;YACb,MAAMJ;QACR,OAAO;YACL,0FAA0F;YAC1FtC,SAASsC,KAAKlB,cAAc,CAACnB,MAAM;QACrC,CAAC;IACH;AACF;AAEA,SAAS0C,cACPL,IAA6C,EAC7CH,SAAsC,EACtCZ,gBAAqD,EACrD;IACA,IAAIe,KAAKtB,KAAK,KAAK,GAAG;QACpB,OAAO,IAAI;IACb,CAAC;IACD,MAAOsB,KAAKpC,WAAW,IAAIoC,KAAKpC,WAAW,KAAKqB,iBAAiB7B,IAAI,CAACI,KAAK,CAAE;QAC3E,IAAI,CAACqC,UAAUS,GAAG,CAACN,KAAKpC,WAAW,GAAG;YACpC,OAAO,KAAK;QACd,CAAC;QACD,MAAMuC,SAASlB,iBAAiBhB,GAAG,CAAC+B,KAAKpC,WAAW;QACpD,IAAI,CAACuC,QAAQ;YACX,OAAO,KAAK;QACd,CAAC;QACDH,OAAOG;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.map

@@ -1 +1 @@
-{"version":3,"sources":["flattenTree.ts"],"sourcesContent":["import { FlatTreeItemProps } from '../hooks/useFlatTree';\nimport { TreeItemProps, TreeItemValue } from '../TreeItem';\n\nexport type NestedTreeItem<Props extends TreeItemProps> = Omit<Props, 'subtree' | 'itemType'> & {\n  value: TreeItemValue;\n  subtree?: NestedTreeItem<Props>[];\n};\n\nexport type FlattenedTreeItem<Props extends TreeItemProps> = FlatTreeItemProps & Props;\n\nfunction flattenTreeRecursive<Props extends TreeItemProps>(\n  items: NestedTreeItem<Props>[],\n  parent?: FlatTreeItemProps & 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: NestedTreeItem<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,KAA8B,EAC9BC,MAAkC,EAClCC,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"}
+{"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/tokens.js

@@ -14,5 +14,6 @@ export const treeDataTypes = {
     Home,
     ArrowUp,
     ArrowDown,
-    TypeAhead: 'TypeAhead'
+    TypeAhead: 'TypeAhead',
+    Change: 'Change'
 };

package/lib/utils/tokens.js.map

@@ -1 +1 @@
-{"version":3,"sources":["tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nimport { 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']]: 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};\n"],"names":["ArrowDown","ArrowLeft","ArrowRight","ArrowUp","End","Home","Enter","treeItemLevelToken","treeAvatarSize","medium","small","treeDataTypes","Click","ExpandIconClick","TypeAhead"],"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;AACb,EAAE"}
+{"version":3,"sources":["tokens.ts"],"sourcesContent":["import { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Home, Enter } from '@fluentui/keyboard-keys';\nimport { TreeCheckedChangeData, TreeNavigationData_unstable, TreeOpenChangeData } from '../Tree';\n\nexport const treeItemLevelToken = '--fluent-TreeItem--level' as const;\n\nexport const treeAvatarSize = {\n  medium: 32,\n  small: 24,\n} as const;\n\nexport const treeDataTypes: {\n  readonly [K in TreeOpenChangeData['type'] | TreeNavigationData_unstable['type'] | TreeCheckedChangeData['type']]: K;\n} = {\n  ArrowLeft,\n  ArrowRight,\n  Enter,\n  Click: 'Click',\n  ExpandIconClick: 'ExpandIconClick',\n  End,\n  Home,\n  ArrowUp,\n  ArrowDown,\n  TypeAhead: 'TypeAhead',\n  Change: 'Change',\n};\n"],"names":["ArrowDown","ArrowLeft","ArrowRight","ArrowUp","End","Home","Enter","treeItemLevelToken","treeAvatarSize","medium","small","treeDataTypes","Click","ExpandIconClick","TypeAhead","Change"],"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-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/components/FlatTree/FlatTree.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FlatTree", {
+    enumerable: true,
+    get: ()=>FlatTree
+});
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+const _index = require("../Tree/index");
+const _useFlatTree = require("./useFlatTree");
+const _useFlatTreeStylesStyles = require("./useFlatTreeStyles.styles");
+const FlatTree = /*#__PURE__*/ _react.forwardRef((props, ref)=>{
+    const state = (0, _useFlatTree.useFlatTree_unstable)(props, ref);
+    const contextValues = (0, _index.useTreeContextValues_unstable)(state);
+    (0, _useFlatTreeStylesStyles.useFlatTreeStyles_unstable)(state);
+    return (0, _index.renderTree_unstable)(state, contextValues);
+});
+FlatTree.displayName = 'FlatTree';

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

@@ -0,0 +1 @@
+{"version":3,"sources":["FlatTree.js"],"sourcesContent":["import * as React from 'react';\nimport { useTreeContextValues_unstable as useFlatTreeContextValues_unstable, renderTree_unstable as renderFlatTree_unstable } from '../Tree/index';\nimport { useFlatTree_unstable } from './useFlatTree';\nimport { useFlatTreeStyles_unstable } from './useFlatTreeStyles.styles';\n/**\n * FlatTree component - TODO: add more docs\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":";;;;+BAMiBA;;aAAAA;;;6DANM;uBAC4G;6BAC9F;yCACM;AAGhC,MAAMA,WAAW,WAAW,GAAGC,OAAMC,UAAU,CAAC,CAACC,OAAOC,MAAM;IACrE,MAAMC,QAAQC,IAAAA,iCAAoB,EAACH,OAAOC;IAC1C,MAAMG,gBAAgBC,IAAAA,oCAAiC,EAACH;IACxDI,IAAAA,mDAA0B,EAACJ;IAC3B,OAAOK,IAAAA,0BAAuB,EAACL,OAAOE;AAC1C;AACAP,SAASW,WAAW,GAAG"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":""}

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    renderFlatTree_unstable: ()=>_index.renderTree_unstable,
+    useFlatTreeContextValues_unstable: ()=>_index.useTreeContextValues_unstable
+});
+const _exportStar = require("@swc/helpers/lib/_export_star.js").default;
+_exportStar(require("./FlatTree"), exports);
+_exportStar(require("./FlatTree.types"), exports);
+const _index = require("../Tree/index");
+_exportStar(require("./useHeadlessFlatTree"), exports);
+_exportStar(require("./useFlatTree"), exports);
+_exportStar(require("./useFlatTreeStyles.styles"), exports);

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

@@ -0,0 +1 @@
+{"version":3,"sources":["index.js"],"sourcesContent":["export * from './FlatTree';\nexport * from './FlatTree.types';\nexport { renderTree_unstable as renderFlatTree_unstable, useTreeContextValues_unstable as useFlatTreeContextValues_unstable } from '../Tree/index';\nexport * from './useHeadlessFlatTree';\nexport * from './useFlatTree';\nexport * from './useFlatTreeStyles.styles';\n"],"names":["renderFlatTree_unstable","renderTree_unstable","useFlatTreeContextValues_unstable","useTreeContextValues_unstable"],"mappings":";;;;;;;;;;;IAEgCA,uBAAuB,MAA9CC,0BAAmB;IAA8DC,iCAAiC,MAAlEC,oCAA6B;;;oBAFxE;oBACA;uBACqH;oBACrH;oBACA;oBACA"}

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    useFlatControllableCheckedItems: ()=>useFlatControllableCheckedItems,
+    createNextFlatCheckedItems: ()=>createNextFlatCheckedItems
+});
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _reactUtilities = require("@fluentui/react-utilities");
+const _immutableMap = require("../../utils/ImmutableMap");
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+const _createCheckedItems = require("../../utils/createCheckedItems");
+function useFlatControllableCheckedItems(props) {
+    const [checkedItems, setCheckedItems] = (0, _reactUtilities.useControllableState)({
+        initialState: _immutableMap.ImmutableMap.empty,
+        state: _react.useMemo(()=>props.checkedItems && (0, _createCheckedItems.createCheckedItems)(props.checkedItems), [
+            props.checkedItems
+        ]),
+        defaultState: ()=>(0, _createCheckedItems.createCheckedItems)(props.defaultCheckedItems)
+    });
+    return [
+        checkedItems,
+        setCheckedItems
+    ];
+}
+function createNextFlatCheckedItems(data, previousCheckedItems, virtualTree) {
+    if (data.selectionMode === 'single') {
+        return _immutableMap.ImmutableMap.create([
+            [
+                data.value,
+                data.checked
+            ]
+        ]);
+    }
+    const treeItem = virtualTree.get(data.value);
+    if (!treeItem) {
+        if (process.env.NODE_ENV !== 'production') {
+            // eslint-disable-next-line no-console
+            console.error(`useHeadlessFlatTree: tree item ${data.value} not found`);
+        }
+        return previousCheckedItems;
+    }
+    const nextCheckedItems = new Map(previousCheckedItems);
+    for (const children of virtualTree.subtree(data.value)){
+        nextCheckedItems.set(children.value, data.checked);
+    }
+    nextCheckedItems.set(data.value, data.checked);
+    let isAncestorsMixed = false;
+    for (const parent of virtualTree.ancestors(treeItem.value)){
+        // if one parent is mixed, all ancestors are mixed
+        if (isAncestorsMixed) {
+            nextCheckedItems.set(parent.value, 'mixed');
+            continue;
+        }
+        const checkedChildren = [];
+        for (const child of virtualTree.children(parent.value)){
+            var _nextCheckedItems_get;
+            if (((_nextCheckedItems_get = nextCheckedItems.get(child.value)) !== null && _nextCheckedItems_get !== void 0 ? _nextCheckedItems_get : false) === data.checked) {
+                checkedChildren.push(child);
+            }
+        }
+        if (checkedChildren.length === parent.childrenValues.length) {
+            nextCheckedItems.set(parent.value, data.checked);
+        } else {
+            // if one parent is mixed, all ancestors are mixed
+            isAncestorsMixed = true;
+            nextCheckedItems.set(parent.value, 'mixed');
+        }
+    }
+    return _immutableMap.ImmutableMap.dangerouslyCreate_unstable(nextCheckedItems);
+}

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

@@ -0,0 +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) {\n    const [checkedItems, setCheckedItems] = useControllableState({\n        initialState: ImmutableMap.empty,\n        state: React.useMemo(()=>props.checkedItems && createCheckedItems(props.checkedItems), [\n            props.checkedItems\n        ]),\n        defaultState: ()=>createCheckedItems(props.defaultCheckedItems)\n    });\n    return [\n        checkedItems,\n        setCheckedItems\n    ];\n}\nexport function createNextFlatCheckedItems(data, previousCheckedItems, virtualTree) {\n    if (data.selectionMode === 'single') {\n        return ImmutableMap.create([\n            [\n                data.value,\n                data.checked\n            ]\n        ]);\n    }\n    const treeItem = virtualTree.get(data.value);\n    if (!treeItem) {\n        if (process.env.NODE_ENV !== 'production') {\n            // eslint-disable-next-line no-console\n            console.error(`useHeadlessFlatTree: tree item ${data.value} not found`);\n        }\n        return previousCheckedItems;\n    }\n    const nextCheckedItems = new Map(previousCheckedItems);\n    for (const children of virtualTree.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 virtualTree.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 virtualTree.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}\n"],"names":["useFlatControllableCheckedItems","createNextFlatCheckedItems","props","checkedItems","setCheckedItems","useControllableState","initialState","ImmutableMap","empty","state","React","useMemo","createCheckedItems","defaultState","defaultCheckedItems","data","previousCheckedItems","virtualTree","selectionMode","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"],"mappings":";;;;;;;;;;;IAIgBA,+BAA+B,MAA/BA;IAaAC,0BAA0B,MAA1BA;;;gCAjBqB;8BACR;6DACN;oCACY;AAC5B,SAASD,gCAAgCE,KAAK,EAAE;IACnD,MAAM,CAACC,cAAcC,gBAAgB,GAAGC,IAAAA,oCAAoB,EAAC;QACzDC,cAAcC,0BAAY,CAACC,KAAK;QAChCC,OAAOC,OAAMC,OAAO,CAAC,IAAIT,MAAMC,YAAY,IAAIS,IAAAA,sCAAkB,EAACV,MAAMC,YAAY,GAAG;YACnFD,MAAMC,YAAY;SACrB;QACDU,cAAc,IAAID,IAAAA,sCAAkB,EAACV,MAAMY,mBAAmB;IAClE;IACA,OAAO;QACHX;QACAC;KACH;AACL;AACO,SAASH,2BAA2Bc,IAAI,EAAEC,oBAAoB,EAAEC,WAAW,EAAE;IAChF,IAAIF,KAAKG,aAAa,KAAK,UAAU;QACjC,OAAOX,0BAAY,CAACY,MAAM,CAAC;YACvB;gBACIJ,KAAKK,KAAK;gBACVL,KAAKM,OAAO;aACf;SACJ;IACL,CAAC;IACD,MAAMC,WAAWL,YAAYM,GAAG,CAACR,KAAKK,KAAK;IAC3C,IAAI,CAACE,UAAU;QACX,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACvC,sCAAsC;YACtCC,QAAQC,KAAK,CAAC,CAAC,+BAA+B,EAAEb,KAAKK,KAAK,CAAC,UAAU,CAAC;QAC1E,CAAC;QACD,OAAOJ;IACX,CAAC;IACD,MAAMa,mBAAmB,IAAIC,IAAId;IACjC,KAAK,MAAMe,YAAYd,YAAYe,OAAO,CAACjB,KAAKK,KAAK,EAAE;QACnDS,iBAAiBI,GAAG,CAACF,SAASX,KAAK,EAAEL,KAAKM,OAAO;IACrD;IACAQ,iBAAiBI,GAAG,CAAClB,KAAKK,KAAK,EAAEL,KAAKM,OAAO;IAC7C,IAAIa,mBAAmB,KAAK;IAC5B,KAAK,MAAMC,UAAUlB,YAAYmB,SAAS,CAACd,SAASF,KAAK,EAAE;QACvD,kDAAkD;QAClD,IAAIc,kBAAkB;YAClBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;YACnC,QAAS;QACb,CAAC;QACD,MAAMiB,kBAAkB,EAAE;QAC1B,KAAK,MAAMC,SAASrB,YAAYc,QAAQ,CAACI,OAAOf,KAAK,EAAE;YACnD,IAAImB;YACJ,IAAI,AAAC,CAAA,AAACA,CAAAA,wBAAwBV,iBAAiBN,GAAG,CAACe,MAAMlB,KAAK,CAAA,MAAO,IAAI,IAAImB,0BAA0B,KAAK,IAAIA,wBAAwB,KAAK,AAAD,MAAOxB,KAAKM,OAAO,EAAE;gBAC7JgB,gBAAgBG,IAAI,CAACF;YACzB,CAAC;QACL;QACA,IAAID,gBAAgBI,MAAM,KAAKN,OAAOO,cAAc,CAACD,MAAM,EAAE;YACzDZ,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAEL,KAAKM,OAAO;QACnD,OAAO;YACH,kDAAkD;YAClDa,mBAAmB,IAAI;YACvBL,iBAAiBI,GAAG,CAACE,OAAOf,KAAK,EAAE;QACvC,CAAC;IACL;IACA,OAAOb,0BAAY,CAACoC,0BAA0B,CAACd;AACnD"}

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "useFlatTree_unstable", {
+    enumerable: true,
+    get: ()=>useFlatTree_unstable
+});
+const _interopRequireWildcard = require("@swc/helpers/lib/_interop_require_wildcard.js").default;
+const _react = /*#__PURE__*/ _interopRequireWildcard(require("react"));
+const _useRootTree = require("../../hooks/useRootTree");
+const useFlatTree_unstable = _useRootTree.useRootTree;

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

@@ -0,0 +1 @@
+{"version":3,"sources":["useFlatTree.js"],"sourcesContent":["import * as React from 'react';\nimport { useRootTree } from '../../hooks/useRootTree';\nexport const useFlatTree_unstable = useRootTree;\n"],"names":["useFlatTree_unstable","useRootTree"],"mappings":";;;;+BAEaA;;aAAAA;;;6DAFU;6BACK;AACrB,MAAMA,uBAAuBC,wBAAW"}

package/lib-commonjs/{hooks → components/FlatTree}/useFlatTreeNavigation.js

@@ -8,13 +8,13 @@ Object.defineProperty(exports, "useFlatTreeNavigation", {
 });
 const _reactSharedContexts = require("@fluentui/react-shared-contexts");
 const _reactUtilities = require("@fluentui/react-utilities");
-const _nextTypeAheadElement = require("../utils/nextTypeAheadElement");
-const _tokens = require("../utils/tokens");
-const _treeItemFilter = require("../utils/treeItemFilter");
-const _useHTMLElementWalker = require("./useHTMLElementWalker");
-const _useRovingTabIndexes = require("./useRovingTabIndexes");
-const _getTreeItemValueFromElement = require("../utils/getTreeItemValueFromElement");
-function useFlatTreeNavigation(flatTreeItems) {
+const _nextTypeAheadElement = require("../../utils/nextTypeAheadElement");
+const _tokens = require("../../utils/tokens");
+const _treeItemFilter = require("../../utils/treeItemFilter");
+const _useHTMLElementWalker = require("../../hooks/useHTMLElementWalker");
+const _useRovingTabIndexes = require("../../hooks/useRovingTabIndexes");
+const _getTreeItemValueFromElement = require("../../utils/getTreeItemValueFromElement");
+function useFlatTreeNavigation(virtualTree) {
     const { targetDocument  } = (0, _reactSharedContexts.useFluent_unstable)();
     const [treeItemWalkerRef, treeItemWalkerRootRef] = (0, _useHTMLElementWalker.useHTMLElementWalkerRef)(_treeItemFilter.treeItemFilter);
     const [{ rove  }, rovingRootRef] = (0, _useRovingTabIndexes.useRovingTabIndex)(_treeItemFilter.treeItemFilter);
@@ -30,7 +30,7 @@ function useFlatTreeNavigation(flatTreeItems) {
                 treeItemWalker.currentElement = data.target;
                 return (0, _nextTypeAheadElement.nextTypeAheadElement)(treeItemWalker, data.event.key);
             case _tokens.treeDataTypes.ArrowLeft:
-                return parentElement(flatTreeItems, data.target, treeItemWalker);
+                return parentElement(virtualTree, data.target, treeItemWalker);
             case _tokens.treeDataTypes.ArrowRight:
                 treeItemWalker.currentElement = data.target;
                 return firstChild(data.target, treeItemWalker);
@@ -72,14 +72,14 @@ function firstChild(target, treeWalker) {
     }
     return null;
 }
-function parentElement(flatTreeItems, target, treeWalker) {
+function parentElement(virtualTreeItems, target, treeWalker) {
     const value = (0, _getTreeItemValueFromElement.getTreeItemValueFromElement)(target);
     if (value === null) {
         return null;
     }
-    const flatTreeItem = flatTreeItems.get(value);
-    if (flatTreeItem === null || flatTreeItem === void 0 ? void 0 : flatTreeItem.parentValue) {
-        return treeWalker.root.querySelector(`[${_getTreeItemValueFromElement.dataTreeItemValueAttrName}="${flatTreeItem.parentValue}"]`);
+    const virtualTreeItem = virtualTreeItems.get(value);
+    if (virtualTreeItem === null || virtualTreeItem === void 0 ? void 0 : virtualTreeItem.parentValue) {
+        return treeWalker.root.querySelector(`[${_getTreeItemValueFromElement.dataTreeItemValueAttrName}="${virtualTreeItem.parentValue}"]`);
     }
     return null;
 }