@fluentui/react-tree 9.7.7 → 9.7.8

package/lib/hooks/useRootTree.js.map

@@ -1 +1 @@
-{"version":3,"sources":["useRootTree.ts"],"sourcesContent":["import { getIntrinsicElementProps, useEventCallback, slot } from '@fluentui/react-utilities';\nimport type { TreeCheckedChangeData, TreeProps, TreeState } from '../Tree';\nimport * as React from 'react';\nimport { Collapse } from '@fluentui/react-motion-components-preview';\nimport { PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport { TreeContextValue, TreeItemRequest } from '../contexts/treeContext';\nimport { createOpenItems } from '../utils/createOpenItems';\nimport { createCheckedItems } from '../utils/createCheckedItems';\nimport { treeDataTypes } from '../utils/tokens';\nimport { createNextOpenItems } from './useControllableOpenItems';\n\n/**\n * Create the state required to render the root level tree.\n *\n * @param props - props from this instance of tree\n * @param ref - reference to root HTMLElement of tree\n */\nexport function useRootTree(\n  props: TreeProps,\n  ref: React.Ref<HTMLElement>,\n): Omit<TreeState & TreeContextValue, 'treeType'> {\n  warnIfNoProperPropsRootTree(props);\n\n  const { appearance = 'subtle', size = 'medium', selectionMode = 'none' } = props;\n\n  const openItems = React.useMemo(() => createOpenItems(props.openItems), [props.openItems]);\n  const checkedItems = React.useMemo(() => createCheckedItems(props.checkedItems), [props.checkedItems]);\n\n  const requestOpenChange = (request: Extract<TreeItemRequest, { requestType: 'open' }>) => {\n    props.onOpenChange?.(request.event, {\n      ...request,\n      openItems: createNextOpenItems(request, openItems).dangerouslyGetInternalSet_unstable(),\n    });\n  };\n\n  const requestCheckedChange = (request: Extract<TreeItemRequest, { requestType: 'selection' }>) => {\n    if (selectionMode === 'none') {\n      return;\n    }\n    props.onCheckedChange?.(request.event, {\n      ...request,\n      selectionMode,\n      checkedItems: checkedItems.dangerouslyGetInternalMap_unstable(),\n      // Casting is required here due to selection | multiselection spreading the union problem\n    } as TreeCheckedChangeData);\n  };\n\n  const requestNavigation = (request: Extract<TreeItemRequest, { requestType: 'navigate' }>) => {\n    let isScrollPrevented = false;\n    props.onNavigation?.(request.event, {\n      ...request,\n      preventScroll: () => {\n        isScrollPrevented = true;\n      },\n      isScrollPrevented: () => isScrollPrevented,\n    });\n    switch (request.type) {\n      case treeDataTypes.ArrowDown:\n      case treeDataTypes.ArrowUp:\n      case treeDataTypes.Home:\n      case treeDataTypes.End:\n        // stop the default behavior of the event\n        // which is to scroll the page\n        request.event.preventDefault();\n    }\n  };\n\n  const requestTreeResponse = useEventCallback((request: TreeItemRequest) => {\n    switch (request.requestType) {\n      case 'navigate':\n        return requestNavigation(request);\n      case 'open':\n        return requestOpenChange(request);\n      case 'selection':\n        return requestCheckedChange(request);\n    }\n  });\n\n  return {\n    components: {\n      root: 'div',\n      // TODO: remove once React v18 slot API is modified\n      // This is a problem at the moment due to UnknownSlotProps assumption\n      // that `children` property is `ReactNode`, which in this case is not valid\n      // as PresenceComponentProps['children'] is `ReactElement`\n      collapseMotion: Collapse as React.FC<PresenceMotionSlotProps>,\n    },\n    contextType: 'root',\n    selectionMode,\n    open: true,\n    appearance,\n    size,\n    level: 1,\n    openItems,\n    checkedItems,\n    requestTreeResponse,\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        role: 'tree',\n        'aria-multiselectable': selectionMode === 'multiselect' ? true : undefined,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n    collapseMotion: undefined,\n  };\n}\n\nfunction warnIfNoProperPropsRootTree(props: Pick<TreeProps, 'aria-label' | 'aria-labelledby'>) {\n  if (process.env.NODE_ENV === 'development') {\n    if (!props['aria-label'] && !props['aria-labelledby']) {\n      // eslint-disable-next-line no-console\n      console.warn(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useRootTree]:\n        Tree must have either a \\`aria-label\\` or \\`aria-labelledby\\` property defined\n      `);\n    }\n  }\n}\n"],"names":["getIntrinsicElementProps","useEventCallback","slot","React","Collapse","createOpenItems","createCheckedItems","treeDataTypes","createNextOpenItems","useRootTree","props","ref","warnIfNoProperPropsRootTree","appearance","size","selectionMode","openItems","useMemo","checkedItems","requestOpenChange","request","onOpenChange","event","dangerouslyGetInternalSet_unstable","requestCheckedChange","onCheckedChange","dangerouslyGetInternalMap_unstable","requestNavigation","isScrollPrevented","onNavigation","preventScroll","type","ArrowDown","ArrowUp","Home","End","preventDefault","requestTreeResponse","requestType","components","root","collapseMotion","contextType","open","level","always","role","undefined","elementType","process","env","NODE_ENV","console","warn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["useRootTree.ts"],"sourcesContent":["import { getIntrinsicElementProps, useEventCallback, slot } from '@fluentui/react-utilities';\nimport type { TreeCheckedChangeData, TreeProps, TreeState } from '../Tree';\nimport * as React from 'react';\nimport { Collapse } from '@fluentui/react-motion-components-preview';\nimport { PresenceMotionSlotProps } from '@fluentui/react-motion';\nimport { TreeContextValue, TreeItemRequest } from '../contexts/treeContext';\nimport { createCheckedItems } from '../utils/createCheckedItems';\nimport { treeDataTypes } from '../utils/tokens';\nimport { createNextOpenItems } from './useControllableOpenItems';\nimport { ImmutableSet } from '../utils/ImmutableSet';\nimport { ImmutableMap } from '../utils/ImmutableMap';\n\n/**\n * Create the state required to render the root level tree.\n *\n * @param props - props from this instance of tree\n * @param ref - reference to root HTMLElement of tree\n */\nexport function useRootTree(\n  props: TreeProps,\n  ref: React.Ref<HTMLElement>,\n): Omit<TreeState & TreeContextValue, 'treeType'> {\n  warnIfNoProperPropsRootTree(props);\n\n  const { appearance = 'subtle', size = 'medium', selectionMode = 'none' } = props;\n\n  const openItems = React.useMemo(() => ImmutableSet.from(props.openItems), [props.openItems]);\n  const checkedItems = React.useMemo(() => createCheckedItems(props.checkedItems), [props.checkedItems]);\n\n  const requestOpenChange = (request: Extract<TreeItemRequest, { requestType: 'open' }>) => {\n    props.onOpenChange?.(request.event, {\n      ...request,\n      openItems: ImmutableSet.dangerouslyGetInternalSet(createNextOpenItems(request, openItems)),\n    });\n  };\n\n  const requestCheckedChange = (request: Extract<TreeItemRequest, { requestType: 'selection' }>) => {\n    if (selectionMode === 'none') {\n      return;\n    }\n    props.onCheckedChange?.(request.event, {\n      ...request,\n      selectionMode,\n      checkedItems: ImmutableMap.dangerouslyGetInternalMap(checkedItems),\n      // Casting is required here due to selection | multiselection spreading the union problem\n    } as TreeCheckedChangeData);\n  };\n\n  const requestNavigation = (request: Extract<TreeItemRequest, { requestType: 'navigate' }>) => {\n    let isScrollPrevented = false;\n    props.onNavigation?.(request.event, {\n      ...request,\n      preventScroll: () => {\n        isScrollPrevented = true;\n      },\n      isScrollPrevented: () => isScrollPrevented,\n    });\n    switch (request.type) {\n      case treeDataTypes.ArrowDown:\n      case treeDataTypes.ArrowUp:\n      case treeDataTypes.Home:\n      case treeDataTypes.End:\n        // stop the default behavior of the event\n        // which is to scroll the page\n        request.event.preventDefault();\n    }\n  };\n\n  const requestTreeResponse = useEventCallback((request: TreeItemRequest) => {\n    switch (request.requestType) {\n      case 'navigate':\n        return requestNavigation(request);\n      case 'open':\n        return requestOpenChange(request);\n      case 'selection':\n        return requestCheckedChange(request);\n    }\n  });\n\n  return {\n    components: {\n      root: 'div',\n      // TODO: remove once React v18 slot API is modified\n      // This is a problem at the moment due to UnknownSlotProps assumption\n      // that `children` property is `ReactNode`, which in this case is not valid\n      // as PresenceComponentProps['children'] is `ReactElement`\n      collapseMotion: Collapse as React.FC<PresenceMotionSlotProps>,\n    },\n    contextType: 'root',\n    selectionMode,\n    open: true,\n    appearance,\n    size,\n    level: 1,\n    openItems,\n    checkedItems,\n    requestTreeResponse,\n    root: slot.always(\n      getIntrinsicElementProps('div', {\n        // FIXME:\n        // `ref` is wrongly assigned to be `HTMLElement` instead of `HTMLDivElement`\n        // but since it would be a breaking change to fix it, we are casting ref to it's proper type\n        ref: ref as React.Ref<HTMLDivElement>,\n        role: 'tree',\n        'aria-multiselectable': selectionMode === 'multiselect' ? true : undefined,\n        ...props,\n      }),\n      { elementType: 'div' },\n    ),\n    collapseMotion: undefined,\n  };\n}\n\nfunction warnIfNoProperPropsRootTree(props: Pick<TreeProps, 'aria-label' | 'aria-labelledby'>) {\n  if (process.env.NODE_ENV === 'development') {\n    if (!props['aria-label'] && !props['aria-labelledby']) {\n      // eslint-disable-next-line no-console\n      console.warn(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useRootTree]:\n        Tree must have either a \\`aria-label\\` or \\`aria-labelledby\\` property defined\n      `);\n    }\n  }\n}\n"],"names":["getIntrinsicElementProps","useEventCallback","slot","React","Collapse","createCheckedItems","treeDataTypes","createNextOpenItems","ImmutableSet","ImmutableMap","useRootTree","props","ref","warnIfNoProperPropsRootTree","appearance","size","selectionMode","openItems","useMemo","from","checkedItems","requestOpenChange","request","onOpenChange","event","dangerouslyGetInternalSet","requestCheckedChange","onCheckedChange","dangerouslyGetInternalMap","requestNavigation","isScrollPrevented","onNavigation","preventScroll","type","ArrowDown","ArrowUp","Home","End","preventDefault","requestTreeResponse","requestType","components","root","collapseMotion","contextType","open","level","always","role","undefined","elementType","process","env","NODE_ENV","console","warn"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/lib/utils/ImmutableMap.js

@@ -1,41 +1,72 @@
-const emptyImmutableMap = createImmutableMap();
-/**
- * properly creates an ImmutableMap instance from an iterable
- */ function createImmutableMap(iterable) {
-    const internalMap = new Map(iterable);
-    return dangerouslyCreateImmutableMap(internalMap);
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+const internalMapSymbol = Symbol('#internalMap');
+let _internalMapSymbol = internalMapSymbol, _Symbol_hasInstance = Symbol.hasInstance, _Symbol_iterator = Symbol.iterator;
+export class ImmutableMap {
+    static dangerouslyGetInternalMap(immutableMap) {
+        return immutableMap[internalMapSymbol];
+    }
+    static copy(immutableMap) {
+        return this.from(immutableMap[internalMapSymbol]);
+    }
+    static from(iterable, mapFn) {
+        if (iterable === undefined) {
+            return this.empty;
+        }
+        if (!mapFn) {
+            if (iterable instanceof this) {
+                return iterable;
+            }
+            // casting here is ok, as the function overload ensures that the iterable is
+            // Iterable<[unknown, unknown]>
+            // if mapFn is not provided
+            const iterableAsTuple = iterable;
+            return new this(new Map(iterableAsTuple));
+        }
+        const map = new Map();
+        for (const value of iterable){
+            map.set(...mapFn(value));
+        }
+        return new this(map);
+    }
+    static [_Symbol_hasInstance](instance) {
+        return Boolean(typeof instance === 'object' && instance && internalMapSymbol in instance);
+    }
+    delete(key) {
+        if (!this.has(key)) {
+            return this;
+        }
+        const copy = ImmutableMap.copy(this);
+        copy[internalMapSymbol].delete(key);
+        return copy;
+    }
+    get(key) {
+        return this[internalMapSymbol].get(key);
+    }
+    has(key) {
+        return this[internalMapSymbol].has(key);
+    }
+    set(key, value) {
+        if (this.get(key) === value) {
+            return this;
+        }
+        const copy = ImmutableMap.copy(this);
+        copy[internalMapSymbol].set(key, value);
+        return copy;
+    }
+    [_Symbol_iterator]() {
+        return this[internalMapSymbol].entries();
+    }
+    /**
+   * Do not use this constructor directly, use {@link ImmutableMap.from} instead.
+   * {@link ImmutableMap.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),
+   * avoid unnecessary copies, supports iterables and ensures that the internal map is never exposed.
+   *
+   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable map, as it is not guaranteed that the internal map is not exposed._ ⚠️⚠️
+   */ constructor(internalMap){
+        _define_property(this, "size", void 0);
+        _define_property(this, _internalMapSymbol, void 0);
+        this[internalMapSymbol] = internalMap;
+        this.size = this[internalMapSymbol].size;
+    }
 }
-/**
- * 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
-};
+_define_property(ImmutableMap, "empty", new ImmutableMap(new Map()));

package/lib/utils/ImmutableMap.js.map

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

package/lib/utils/ImmutableSet.js

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

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  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"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAiCA,MAAMA,oBAAoBC;AAE1B;;;CAGC,GACD,SAASC,8BAAqCC,WAAuB;IACnE,OAAO;QACLC,MAAMD,YAAYC,IAAI;QACtBC,KAAIC,KAAK;YACP,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQF,GAAG,CAACC;YACZ,OAAOJ,8BAA8BK;QACvC;QACAE;YACE,OAAOT;QACT;QACAU,QAAOJ,KAAK;YACV,MAAMC,UAAU,IAAIC,IAAIL;YACxBI,QAAQG,MAAM,CAACJ;YACf,OAAOJ,8BAA8BK;QACvC;QACAI,KAAIL,KAAK;YACP,OAAOH,YAAYQ,GAAG,CAACL;QACzB;QACA,CAACM,OAAOC,QAAQ,CAAC;YACf,OAAOV,WAAW,CAACS,OAAOC,QAAQ,CAAC;QACrC;QACA,gEAAgE;QAChEC,oCAAoC,IAAMX;IAC5C;AACF;AAEA,SAASY,eAAsBT,KAAc;IAC3C,OAAO,OAAOA,UAAU,YAAYA,UAAU,QAAQ,wCAAwCA;AAChG;AAEA;;CAEC,GACD,SAASL,mBAA0Be,QAA0B;IAC3D,MAAMb,cAAc,IAAIK,IAAIQ;IAC5B,OAAOd,8BAA8BC;AACvC;AAEA,OAAO,MAAMc,eAAe;IAC1BC,OAAOlB;IACPmB,QAAQlB;IACRc;IACA,gEAAgE;IAChEK,4BAA4BlB;AAC9B,EAAE"}
+{"version":3,"sources":["ImmutableSet.ts"],"sourcesContent":["const internalSetSymbol = Symbol('#internalSet');\n\n/**\n * @public\n *\n * Small immutable wrapper around the native Set implementation.\n * Every operation that would modify the set returns a new copy instance.\n */\nexport class ImmutableSet<T> implements Iterable<T> {\n  public static empty: ImmutableSet<never> = new ImmutableSet(new Set());\n  public readonly size: number;\n\n  private [internalSetSymbol]: Set<T>;\n\n  public static dangerouslyGetInternalSet<Value>(set: ImmutableSet<Value>): Set<Value> {\n    return set[internalSetSymbol];\n  }\n\n  public static copy<T>(immutableSet: ImmutableSet<T>): ImmutableSet<T> {\n    return new ImmutableSet(new Set(immutableSet[internalSetSymbol]));\n  }\n\n  /**\n   * Creates a new {@link ImmutableSet} from an iterable.\n   * If the iterable is undefined, {@link ImmutableSet.empty} will be returned.\n   * If the iterable is already an {@link ImmutableSet}, it will be returned as is no copy will be made.\n   */\n  public static from<Value>(iterable?: Iterable<Value>): ImmutableSet<Value> {\n    if (iterable === undefined) {\n      return this.empty;\n    }\n    if (iterable instanceof this) {\n      return iterable;\n    }\n    return new this(new Set(iterable));\n  }\n\n  public static [Symbol.hasInstance](instance: unknown): boolean {\n    return Boolean(typeof instance === 'object' && instance && internalSetSymbol in instance);\n  }\n\n  /**\n   * Do not use this constructor directly, use {@link ImmutableSet.from} instead.\n   * {@link ImmutableSet.from} handles instance verification (which might be problematic on {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/instanceof#instanceof_and_multiple_realms | multiple realms}),\n   * avoid unnecessary copies, supports iterables and ensures that the internal set is never exposed.\n   *\n   *⚠️⚠️  _By using this constructor directly, you might end up with a mutable set, as it is not guaranteed that the internal set is not exposed._ ⚠️⚠️\n   */\n  constructor(internalSet: Set<T>) {\n    this[internalSetSymbol] = internalSet;\n    this.size = this[internalSetSymbol].size;\n  }\n\n  public add(value: T): ImmutableSet<T> {\n    if (this.has(value)) {\n      return this;\n    }\n    const copy = ImmutableSet.copy(this);\n    copy[internalSetSymbol].add(value);\n    return copy;\n  }\n\n  public delete(value: T): ImmutableSet<T> {\n    if (!this.has(value)) {\n      return this;\n    }\n    const copy = ImmutableSet.copy(this);\n    copy[internalSetSymbol].delete(value);\n    return copy;\n  }\n\n  public has(value: T): boolean {\n    return this[internalSetSymbol].has(value);\n  }\n\n  public [Symbol.iterator](): Iterator<T> {\n    return this[internalSetSymbol].values();\n  }\n}\n"],"names":["internalSetSymbol","Symbol","hasInstance","iterator","ImmutableSet","dangerouslyGetInternalSet","set","copy","immutableSet","Set","from","iterable","undefined","empty","instance","Boolean","add","value","has","delete","values","constructor","internalSet","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";AAAA,MAAMA,oBAAoBC,OAAO;IAYtBD,qBAAAA,mBAyBMC,sBAAAA,OAAOC,WAAW,EAsCzBD,mBAAAA,OAAOE,QAAQ;AAzEzB;;;;;CAKC,GACD,OAAO,MAAMC;IAMX,OAAcC,0BAAiCC,GAAwB,EAAc;QACnF,OAAOA,GAAG,CAACN,kBAAkB;IAC/B;IAEA,OAAcO,KAAQC,YAA6B,EAAmB;QACpE,OAAO,IAAIJ,aAAa,IAAIK,IAAID,YAAY,CAACR,kBAAkB;IACjE;IAEA;;;;GAIC,GACD,OAAcU,KAAYC,QAA0B,EAAuB;QACzE,IAAIA,aAAaC,WAAW;YAC1B,OAAO,IAAI,CAACC,KAAK;QACnB;QACA,IAAIF,oBAAoB,IAAI,EAAE;YAC5B,OAAOA;QACT;QACA,OAAO,IAAI,IAAI,CAAC,IAAIF,IAAIE;IAC1B;IAEA,OAAc,CAACV,oBAAmB,CAACa,QAAiB,EAAW;QAC7D,OAAOC,QAAQ,OAAOD,aAAa,YAAYA,YAAYd,qBAAqBc;IAClF;IAcOE,IAAIC,KAAQ,EAAmB;QACpC,IAAI,IAAI,CAACC,GAAG,CAACD,QAAQ;YACnB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOH,aAAaG,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACP,kBAAkB,CAACgB,GAAG,CAACC;QAC5B,OAAOV;IACT;IAEOY,OAAOF,KAAQ,EAAmB;QACvC,IAAI,CAAC,IAAI,CAACC,GAAG,CAACD,QAAQ;YACpB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOH,aAAaG,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACP,kBAAkB,CAACmB,MAAM,CAACF;QAC/B,OAAOV;IACT;IAEOW,IAAID,KAAQ,EAAW;QAC5B,OAAO,IAAI,CAACjB,kBAAkB,CAACkB,GAAG,CAACD;IACrC;IAEO,CAAChB,iBAAgB,GAAgB;QACtC,OAAO,IAAI,CAACD,kBAAkB,CAACoB,MAAM;IACvC;IApCA;;;;;;GAMC,GACDC,YAAYC,WAAmB,CAAE;QAtCjC,uBAAgBC,QAAhB,KAAA;QAEA,uBAASvB,oBAAT,KAAA;QAqCE,IAAI,CAACA,kBAAkB,GAAGsB;QAC1B,IAAI,CAACC,IAAI,GAAG,IAAI,CAACvB,kBAAkB,CAACuB,IAAI;IAC1C;AA2BF;AArEE,iBADWnB,cACGS,SAA6B,IAAIT,aAAa,IAAIK"}

package/lib/utils/createCheckedItems.js

@@ -1,18 +1,6 @@
 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);
-}
+const tuplifyCheckedItem = (value)=>Array.isArray(value) ? value : [
+        value,
+        true
+    ];
+export const createCheckedItems = (iterable)=>ImmutableMap.from(iterable, tuplifyCheckedItem);

package/lib/utils/createCheckedItems.js.map

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

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

@@ -33,7 +33,7 @@ function useFlatControllableCheckedItems(props, headlessTree) {
 }
 function createNextFlatCheckedItems(data, previousCheckedItems, headlessTree) {
     if (data.selectionMode === 'single') {
-        return _ImmutableMap.ImmutableMap.create([
+        return _ImmutableMap.ImmutableMap.from([
             [
                 data.value,
                 data.checked
@@ -49,40 +49,42 @@ Tree item ${data.value} not found.`);
         }
         return previousCheckedItems;
     }
-    const nextCheckedItems = new Map(previousCheckedItems);
+    let nextCheckedItems = previousCheckedItems;
     for (const children of headlessTree.subtree(data.value)){
-        nextCheckedItems.set(children.value, data.checked);
+        nextCheckedItems = nextCheckedItems.set(children.value, data.checked);
     }
-    nextCheckedItems.set(data.value, data.checked);
+    nextCheckedItems = nextCheckedItems.set(data.value, data.checked);
     let isAncestorsMixed = false;
     for (const parent of headlessTree.ancestors(treeItem.value)){
         // if one parent is mixed, all ancestors are mixed
         if (isAncestorsMixed) {
-            nextCheckedItems.set(parent.value, 'mixed');
+            nextCheckedItems = nextCheckedItems.set(parent.value, 'mixed');
             continue;
         }
-        const checkedChildren = [];
+        let checkedChildrenAmount = 0;
         for (const child of headlessTree.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 ((nextCheckedItems.get(child.value) || false) === data.checked) {
+                checkedChildrenAmount++;
             }
         }
-        if (checkedChildren.length === parent.childrenValues.length) {
-            nextCheckedItems.set(parent.value, data.checked);
+        // if all children are checked, parent is checked
+        if (checkedChildrenAmount === parent.childrenValues.length) {
+            nextCheckedItems = nextCheckedItems.set(parent.value, data.checked);
         } else {
             // if one parent is mixed, all ancestors are mixed
             isAncestorsMixed = true;
-            nextCheckedItems.set(parent.value, 'mixed');
+            nextCheckedItems = nextCheckedItems.set(parent.value, 'mixed');
         }
     }
-    return _ImmutableMap.ImmutableMap.dangerouslyCreate_unstable(nextCheckedItems);
+    return nextCheckedItems;
 }
 function initializeCheckedItems(props, headlessTree) {
     if (!props.selectionMode) {
         return _ImmutableMap.ImmutableMap.empty;
     }
     let state = (0, _createCheckedItems.createCheckedItems)(props.defaultCheckedItems);
+    // if selectionMode is multiselect, we need to calculate the checked state of all children
+    // and ancestors of the defaultCheckedItems
     if (props.selectionMode === 'multiselect') {
         for (const [value, checked] of state){
             state = createNextFlatCheckedItems({

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

@@ -1 +1 @@
-{"version":3,"sources":["useFlatControllableCheckedItems.ts"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport { TreeItemValue } from '../../TreeItem';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport * as React from 'react';\nimport type { HeadlessTree, HeadlessTreeItemProps } from '../../utils/createHeadlessTree';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nimport type { TreeCheckedChangeData } from '../Tree/Tree.types';\nimport { HeadlessFlatTreeOptions } from './useHeadlessFlatTree';\n\nexport function useFlatControllableCheckedItems<Props extends HeadlessTreeItemProps>(\n  props: Pick<HeadlessFlatTreeOptions, 'checkedItems' | 'defaultCheckedItems' | 'selectionMode'>,\n  headlessTree: HeadlessTree<Props>,\n) {\n  return useControllableState({\n    initialState: ImmutableMap.empty,\n    state: React.useMemo(\n      () => (props.selectionMode ? props.checkedItems && createCheckedItems(props.checkedItems) : undefined),\n      [props.checkedItems, props.selectionMode],\n    ),\n    defaultState: props.defaultCheckedItems ? () => initializeCheckedItems(props, headlessTree) : undefined,\n  });\n}\n\nexport function createNextFlatCheckedItems(\n  data: Pick<TreeCheckedChangeData, 'value' | 'checked' | 'selectionMode'>,\n  previousCheckedItems: ImmutableMap<TreeItemValue, 'mixed' | boolean>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n): ImmutableMap<TreeItemValue, 'mixed' | boolean> {\n  if (data.selectionMode === 'single') {\n    return ImmutableMap.create([[data.value, data.checked]]);\n  }\n  const treeItem = headlessTree.get(data.value);\n  if (!treeItem) {\n    if (process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line no-console\n      console.error(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useHeadlessFlatTree]:\n        Tree item ${data.value} not found.\n      `);\n    }\n    return previousCheckedItems;\n  }\n  const nextCheckedItems = new Map(previousCheckedItems);\n  for (const children of headlessTree.subtree(data.value)) {\n    nextCheckedItems.set(children.value, data.checked);\n  }\n  nextCheckedItems.set(data.value, data.checked);\n\n  let isAncestorsMixed = false;\n  for (const parent of headlessTree.ancestors(treeItem.value)) {\n    // if one parent is mixed, all ancestors are mixed\n    if (isAncestorsMixed) {\n      nextCheckedItems.set(parent.value, 'mixed');\n      continue;\n    }\n    const checkedChildren = [];\n    for (const child of headlessTree.children(parent.value)) {\n      if ((nextCheckedItems.get(child.value) ?? false) === data.checked) {\n        checkedChildren.push(child);\n      }\n    }\n    if (checkedChildren.length === parent.childrenValues.length) {\n      nextCheckedItems.set(parent.value, data.checked);\n    } else {\n      // if one parent is mixed, all ancestors are mixed\n      isAncestorsMixed = true;\n      nextCheckedItems.set(parent.value, 'mixed');\n    }\n  }\n  return ImmutableMap.dangerouslyCreate_unstable(nextCheckedItems);\n}\n\nfunction initializeCheckedItems(\n  props: Pick<HeadlessFlatTreeOptions, 'selectionMode' | 'defaultCheckedItems'>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n) {\n  if (!props.selectionMode) {\n    return ImmutableMap.empty;\n  }\n  let state = createCheckedItems(props.defaultCheckedItems);\n  if (props.selectionMode === 'multiselect') {\n    for (const [value, checked] of state) {\n      state = createNextFlatCheckedItems({ value, checked, selectionMode: props.selectionMode }, state, headlessTree);\n    }\n  }\n  return state;\n}\n"],"names":["createNextFlatCheckedItems","useFlatControllableCheckedItems","props","headlessTree","useControllableState","initialState","ImmutableMap","empty","state","React","useMemo","selectionMode","checkedItems","createCheckedItems","undefined","defaultState","defaultCheckedItems","initializeCheckedItems","data","previousCheckedItems","create","value","checked","treeItem","get","process","env","NODE_ENV","console","error","nextCheckedItems","Map","children","subtree","set","isAncestorsMixed","parent","ancestors","checkedChildren","child","push","length","childrenValues","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}
+{"version":3,"sources":["useFlatControllableCheckedItems.ts"],"sourcesContent":["import { useControllableState } from '@fluentui/react-utilities';\nimport { TreeItemValue } from '../../TreeItem';\nimport { ImmutableMap } from '../../utils/ImmutableMap';\nimport * as React from 'react';\nimport type { HeadlessTree, HeadlessTreeItemProps } from '../../utils/createHeadlessTree';\nimport { createCheckedItems } from '../../utils/createCheckedItems';\nimport type { TreeCheckedChangeData } from '../Tree/Tree.types';\nimport { HeadlessFlatTreeOptions } from './useHeadlessFlatTree';\n\nexport function useFlatControllableCheckedItems<Props extends HeadlessTreeItemProps>(\n  props: Pick<HeadlessFlatTreeOptions, 'checkedItems' | 'defaultCheckedItems' | 'selectionMode'>,\n  headlessTree: HeadlessTree<Props>,\n) {\n  return useControllableState({\n    initialState: ImmutableMap.empty,\n    state: React.useMemo(\n      () => (props.selectionMode ? props.checkedItems && createCheckedItems(props.checkedItems) : undefined),\n      [props.checkedItems, props.selectionMode],\n    ),\n    defaultState: props.defaultCheckedItems ? () => initializeCheckedItems(props, headlessTree) : undefined,\n  });\n}\n\nexport function createNextFlatCheckedItems(\n  data: Pick<TreeCheckedChangeData, 'value' | 'checked' | 'selectionMode'>,\n  previousCheckedItems: ImmutableMap<TreeItemValue, 'mixed' | boolean>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n): ImmutableMap<TreeItemValue, 'mixed' | boolean> {\n  if (data.selectionMode === 'single') {\n    return ImmutableMap.from([[data.value, data.checked]]);\n  }\n  const treeItem = headlessTree.get(data.value);\n  if (!treeItem) {\n    if (process.env.NODE_ENV !== 'production') {\n      // eslint-disable-next-line no-console\n      console.error(/* #__DE-INDENT__ */ `\n        @fluentui/react-tree [useHeadlessFlatTree]:\n        Tree item ${data.value} not found.\n      `);\n    }\n    return previousCheckedItems;\n  }\n  let nextCheckedItems = previousCheckedItems;\n  for (const children of headlessTree.subtree(data.value)) {\n    nextCheckedItems = nextCheckedItems.set(children.value, data.checked);\n  }\n  nextCheckedItems = nextCheckedItems.set(data.value, data.checked);\n\n  let isAncestorsMixed = false;\n  for (const parent of headlessTree.ancestors(treeItem.value)) {\n    // if one parent is mixed, all ancestors are mixed\n    if (isAncestorsMixed) {\n      nextCheckedItems = nextCheckedItems.set(parent.value, 'mixed');\n      continue;\n    }\n    let checkedChildrenAmount = 0;\n    for (const child of headlessTree.children(parent.value)) {\n      if ((nextCheckedItems.get(child.value) || false) === data.checked) {\n        checkedChildrenAmount++;\n      }\n    }\n    // if all children are checked, parent is checked\n    if (checkedChildrenAmount === parent.childrenValues.length) {\n      nextCheckedItems = nextCheckedItems.set(parent.value, data.checked);\n    } else {\n      // if one parent is mixed, all ancestors are mixed\n      isAncestorsMixed = true;\n      nextCheckedItems = nextCheckedItems.set(parent.value, 'mixed');\n    }\n  }\n  return nextCheckedItems;\n}\n\nfunction initializeCheckedItems(\n  props: Pick<HeadlessFlatTreeOptions, 'selectionMode' | 'defaultCheckedItems'>,\n  headlessTree: HeadlessTree<HeadlessTreeItemProps>,\n) {\n  if (!props.selectionMode) {\n    return ImmutableMap.empty;\n  }\n  let state = createCheckedItems(props.defaultCheckedItems);\n  // if selectionMode is multiselect, we need to calculate the checked state of all children\n  // and ancestors of the defaultCheckedItems\n  if (props.selectionMode === 'multiselect') {\n    for (const [value, checked] of state) {\n      state = createNextFlatCheckedItems({ value, checked, selectionMode: props.selectionMode }, state, headlessTree);\n    }\n  }\n  return state;\n}\n"],"names":["createNextFlatCheckedItems","useFlatControllableCheckedItems","props","headlessTree","useControllableState","initialState","ImmutableMap","empty","state","React","useMemo","selectionMode","checkedItems","createCheckedItems","undefined","defaultState","defaultCheckedItems","initializeCheckedItems","data","previousCheckedItems","from","value","checked","treeItem","get","process","env","NODE_ENV","console","error","nextCheckedItems","children","subtree","set","isAncestorsMixed","parent","ancestors","checkedChildrenAmount","child","childrenValues","length"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;;;;;;;;IAuBgBA,0BAAAA;eAAAA;;IAdAC,+BAAAA;eAAAA;;;;gCATqB;8BAER;iEACN;oCAEY;AAI5B,SAASA,gCACdC,KAA8F,EAC9FC,YAAiC;IAEjC,OAAOC,IAAAA,oCAAAA,EAAqB;QAC1BC,cAAcC,0BAAAA,CAAaC,KAAK;QAChCC,OAAOC,OAAMC,OAAO,CAClB,IAAOR,MAAMS,aAAa,GAAGT,MAAMU,YAAY,IAAIC,IAAAA,sCAAAA,EAAmBX,MAAMU,YAAY,IAAIE,WAC5F;YAACZ,MAAMU,YAAY;YAAEV,MAAMS,aAAa;SAAC;QAE3CI,cAAcb,MAAMc,mBAAmB,GAAG,IAAMC,uBAAuBf,OAAOC,gBAAgBW;IAChG;AACF;AAEO,SAASd,2BACdkB,IAAwE,EACxEC,oBAAoE,EACpEhB,YAAiD;IAEjD,IAAIe,KAAKP,aAAa,KAAK,UAAU;QACnC,OAAOL,0BAAAA,CAAac,IAAI,CAAC;YAAC;gBAACF,KAAKG,KAAK;gBAAEH,KAAKI,OAAO;aAAC;SAAC;IACvD;IACA,MAAMC,WAAWpB,aAAaqB,GAAG,CAACN,KAAKG,KAAK;IAC5C,IAAI,CAACE,UAAU;QACb,IAAIE,QAAQC,GAAG,CAACC,QAAQ,KAAK,cAAc;YACzC,sCAAsC;YACtCC,QAAQC,KAAK,CAAsB,CAAC;UAExB,EAAEX,KAAKG,KAAK,CAAC,WACzB,CAAC;QACH;QACA,OAAOF;IACT;IACA,IAAIW,mBAAmBX;IACvB,KAAK,MAAMY,YAAY5B,aAAa6B,OAAO,CAACd,KAAKG,KAAK,EAAG;QACvDS,mBAAmBA,iBAAiBG,GAAG,CAACF,SAASV,KAAK,EAAEH,KAAKI,OAAO;IACtE;IACAQ,mBAAmBA,iBAAiBG,GAAG,CAACf,KAAKG,KAAK,EAAEH,KAAKI,OAAO;IAEhE,IAAIY,mBAAmB;IACvB,KAAK,MAAMC,UAAUhC,aAAaiC,SAAS,CAACb,SAASF,KAAK,EAAG;QAC3D,kDAAkD;QAClD,IAAIa,kBAAkB;YACpBJ,mBAAmBA,iBAAiBG,GAAG,CAACE,OAAOd,KAAK,EAAE;YACtD;QACF;QACA,IAAIgB,wBAAwB;QAC5B,KAAK,MAAMC,SAASnC,aAAa4B,QAAQ,CAACI,OAAOd,KAAK,EAAG;YACvD,IAAI,AAACS,CAAAA,iBAAiBN,GAAG,CAACc,MAAMjB,KAAK,KAAK,KAAA,MAAWH,KAAKI,OAAO,EAAE;gBACjEe;YACF;QACF;QACA,iDAAiD;QACjD,IAAIA,0BAA0BF,OAAOI,cAAc,CAACC,MAAM,EAAE;YAC1DV,mBAAmBA,iBAAiBG,GAAG,CAACE,OAAOd,KAAK,EAAEH,KAAKI,OAAO;QACpE,OAAO;YACL,kDAAkD;YAClDY,mBAAmB;YACnBJ,mBAAmBA,iBAAiBG,GAAG,CAACE,OAAOd,KAAK,EAAE;QACxD;IACF;IACA,OAAOS;AACT;AAEA,SAASb,uBACPf,KAA6E,EAC7EC,YAAiD;IAEjD,IAAI,CAACD,MAAMS,aAAa,EAAE;QACxB,OAAOL,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAIC,QAAQK,IAAAA,sCAAAA,EAAmBX,MAAMc,mBAAmB;IACxD,0FAA0F;IAC1F,2CAA2C;IAC3C,IAAId,MAAMS,aAAa,KAAK,eAAe;QACzC,KAAK,MAAM,CAACU,OAAOC,QAAQ,IAAId,MAAO;YACpCA,QAAQR,2BAA2B;gBAAEqB;gBAAOC;gBAASX,eAAeT,MAAMS,aAAa;YAAC,GAAGH,OAAOL;QACpG;IACF;IACA,OAAOK;AACT"}

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

@@ -16,7 +16,9 @@ const _tokens = require("../../utils/tokens");
 const _useFlatTreeNavigation = require("../../hooks/useFlatTreeNavigation");
 const _useControllableOpenItems = require("../../hooks/useControllableOpenItems");
 const _getTreeItemValueFromElement = require("../../utils/getTreeItemValueFromElement");
+const _ImmutableSet = require("../../utils/ImmutableSet");
 const _useFlatControllableCheckedItems = require("./useFlatControllableCheckedItems");
+const _ImmutableMap = require("../../utils/ImmutableMap");
 function useHeadlessFlatTree_unstable(props, options = {}) {
     'use no memo';
     const headlessTree = _react.useMemo(()=>(0, _createHeadlessTree.createHeadlessTree)(props), [
@@ -31,7 +33,7 @@ function useHeadlessFlatTree_unstable(props, options = {}) {
         const nextOpenItems = (0, _useControllableOpenItems.createNextOpenItems)(data, openItems);
         (_options_onOpenChange = options.onOpenChange) === null || _options_onOpenChange === void 0 ? void 0 : _options_onOpenChange.call(options, event, {
             ...data,
-            openItems: nextOpenItems.dangerouslyGetInternalSet_unstable()
+            openItems: _ImmutableSet.ImmutableSet.dangerouslyGetInternalSet(nextOpenItems)
         });
         setOpenItems(nextOpenItems);
     });
@@ -40,7 +42,7 @@ function useHeadlessFlatTree_unstable(props, options = {}) {
         const nextCheckedItems = (0, _useFlatControllableCheckedItems.createNextFlatCheckedItems)(data, checkedItems, headlessTree);
         (_options_onCheckedChange = options.onCheckedChange) === null || _options_onCheckedChange === void 0 ? void 0 : _options_onCheckedChange.call(options, event, {
             ...data,
-            checkedItems: nextCheckedItems.dangerouslyGetInternalMap_unstable()
+            checkedItems: _ImmutableMap.ImmutableMap.dangerouslyGetInternalMap(nextCheckedItems)
         });
         setCheckedItems(nextCheckedItems);
     });

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

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

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

@@ -27,7 +27,7 @@ function useNestedCheckedItems(props) {
 }
 function createNextNestedCheckedItems(data, previousCheckedItems) {
     if (data.selectionMode === 'single') {
-        return _ImmutableMap.ImmutableMap.create([
+        return _ImmutableMap.ImmutableMap.from([
             [
                 data.value,
                 data.checked