@fluentui/react-tree 9.7.6 → 9.7.8

package/lib-commonjs/utils/ImmutableMap.js

@@ -8,44 +8,75 @@ Object.defineProperty(exports, "ImmutableMap", {
         return ImmutableMap;
     }
 });
-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;
+const _define_property = require("@swc/helpers/_/_define_property");
+const internalMapSymbol = Symbol('#internalMap');
+let _internalMapSymbol = internalMapSymbol, _Symbol_hasInstance = Symbol.hasInstance, _Symbol_iterator = Symbol.iterator;
+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){
+        (0, _define_property._)(this, "size", void 0);
+        (0, _define_property._)(this, _internalMapSymbol, void 0);
+        this[internalMapSymbol] = internalMap;
+        this.size = this[internalMapSymbol].size;
+    }
 }
-const ImmutableMap = {
-    empty: emptyImmutableMap,
-    create: createImmutableMap,
-    isImmutableMap,
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    dangerouslyCreate_unstable: dangerouslyCreateImmutableMap
-};
+(0, _define_property._)(ImmutableMap, "empty", new ImmutableMap(new Map()));

package/lib-commonjs/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":["ImmutableMap","emptyImmutableMap","createImmutableMap","iterable","internalMap","Map","dangerouslyCreateImmutableMap","size","set","key","value","nextSet","get","clear","delete","has","Symbol","iterator","dangerouslyGetInternalMap_unstable","isImmutableMap","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAsEaA;;;eAAAA;;;AAvCb,MAAMC,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;AAEO,MAAMV,eAAe;IAC1BoB,OAAOnB;IACPoB,QAAQnB;IACRiB;IACA,gEAAgE;IAChEG,4BAA4BhB;AAC9B"}
+{"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":["ImmutableMap","internalMapSymbol","Symbol","hasInstance","iterator","dangerouslyGetInternalMap","immutableMap","copy","from","iterable","mapFn","undefined","empty","iterableAsTuple","Map","map","value","set","instance","Boolean","delete","key","has","get","entries","constructor","internalMap","_define_property","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAEaA;;;eAAAA;;;;AAFb,MAAMC,oBAAoBC,OAAO;IAMtBD,qBAAAA,mBAkDMC,sBAAAA,OAAOC,WAAW,EAsCzBD,mBAAAA,OAAOE,QAAQ;AA5FlB,MAAMJ;IAMX,OAAcK,0BAAsCC,YAAsC,EAAmB;QAC3G,OAAOA,YAAY,CAACL,kBAAkB;IACxC;IAEA,OAAcM,KAAiBD,YAAsC,EAA4B;QAC/F,OAAO,IAAI,CAACE,IAAI,CAACF,YAAY,CAACL,kBAAkB;IAClD;IAkBA,OAAcO,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,CAACb,oBAAmB,CAACgB,QAAiB,EAAW;QAC7D,OAAOC,QAAQ,OAAOD,aAAa,YAAYA,YAAYjB,qBAAqBiB;IAClF;IAcOE,OAAOC,GAAQ,EAA4B;QAChD,IAAI,CAAC,IAAI,CAACC,GAAG,CAACD,MAAM;YAClB,OAAO,IAAI;QACb;QACA,MAAMd,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACmB,MAAM,CAACC;QAC/B,OAAOd;IACT;IACOgB,IAAIF,GAAQ,EAAqB;QACtC,OAAO,IAAI,CAACpB,kBAAkB,CAACsB,GAAG,CAACF;IACrC;IACOC,IAAID,GAAQ,EAAW;QAC5B,OAAO,IAAI,CAACpB,kBAAkB,CAACqB,GAAG,CAACD;IACrC;IACOJ,IAAII,GAAQ,EAAEL,KAAY,EAA4B;QAC3D,IAAI,IAAI,CAACO,GAAG,CAACF,SAASL,OAAO;YAC3B,OAAO,IAAI;QACb;QACA,MAAMT,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACgB,GAAG,CAACI,KAAKL;QACjC,OAAOT;IACT;IACO,CAACL,iBAAgB,GAA2B;QACjD,OAAO,IAAI,CAACD,kBAAkB,CAACuB,OAAO;IACxC;IApCA;;;;;;GAMC,GACDC,YAAYC,WAA4B,CAAE;QA/D1CC,IAAAA,kBAAA,EAAA,IAAA,EAAgBC,QAAhB,KAAA;QAEAD,IAAAA,kBAAA,EAAA,IAAA,EAAS1B,oBAAT,KAAA;QA8DE,IAAI,CAACA,kBAAkB,GAAGyB;QAC1B,IAAI,CAACE,IAAI,GAAG,IAAI,CAAC3B,kBAAkB,CAAC2B,IAAI;IAC1C;AA2BF;AA9FED,IAAAA,kBAAA,EADW3B,cACGY,SAAoC,IAAIZ,aAAa,IAAIc"}

package/lib-commonjs/utils/ImmutableSet.js

@@ -8,49 +8,65 @@ Object.defineProperty(exports, "ImmutableSet", {
         return ImmutableSet;
     }
 });
-const emptyImmutableSet = createImmutableSet();
-/**
- * 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
-    };
-}
-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);
+const _define_property = require("@swc/helpers/_/_define_property");
+const internalSetSymbol = Symbol('#internalSet');
+let _internalSetSymbol = internalSetSymbol, _Symbol_hasInstance = Symbol.hasInstance, _Symbol_iterator = Symbol.iterator;
+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){
+        (0, _define_property._)(this, "size", void 0);
+        (0, _define_property._)(this, _internalSetSymbol, void 0);
+        this[internalSetSymbol] = internalSet;
+        this.size = this[internalSetSymbol].size;
+    }
 }
-const ImmutableSet = {
-    empty: emptyImmutableSet,
-    create: createImmutableSet,
-    isImmutableSet,
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    dangerouslyCreate_unstable: dangerouslyCreateImmutableSet
-};
+(0, _define_property._)(ImmutableSet, "empty", new ImmutableSet(new Set()));

package/lib-commonjs/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":["ImmutableSet","emptyImmutableSet","createImmutableSet","dangerouslyCreateImmutableSet","internalSet","size","add","value","nextSet","Set","clear","delete","has","Symbol","iterator","dangerouslyGetInternalSet_unstable","isImmutableSet","iterable","empty","create","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BA8EaA;;;eAAAA;;;AA7Cb,MAAMC,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;AAEO,MAAMJ,eAAe;IAC1BkB,OAAOjB;IACPkB,QAAQjB;IACRc;IACA,gEAAgE;IAChEI,4BAA4BjB;AAC9B"}
+{"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":["ImmutableSet","internalSetSymbol","Symbol","hasInstance","iterator","dangerouslyGetInternalSet","set","copy","immutableSet","Set","from","iterable","undefined","empty","instance","Boolean","add","value","has","delete","values","constructor","internalSet","_define_property","size"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;;AARb,MAAMC,oBAAoBC,OAAO;IAYtBD,qBAAAA,mBAyBMC,sBAAAA,OAAOC,WAAW,EAsCzBD,mBAAAA,OAAOE,QAAQ;AAnElB,MAAMJ;IAMX,OAAcK,0BAAiCC,GAAwB,EAAc;QACnF,OAAOA,GAAG,CAACL,kBAAkB;IAC/B;IAEA,OAAcM,KAAQC,YAA6B,EAAmB;QACpE,OAAO,IAAIR,aAAa,IAAIS,IAAID,YAAY,CAACP,kBAAkB;IACjE;IAEA;;;;GAIC,GACD,OAAcS,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,CAACT,oBAAmB,CAACY,QAAiB,EAAW;QAC7D,OAAOC,QAAQ,OAAOD,aAAa,YAAYA,YAAYb,qBAAqBa;IAClF;IAcOE,IAAIC,KAAQ,EAAmB;QACpC,IAAI,IAAI,CAACC,GAAG,CAACD,QAAQ;YACnB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACe,GAAG,CAACC;QAC5B,OAAOV;IACT;IAEOY,OAAOF,KAAQ,EAAmB;QACvC,IAAI,CAAC,IAAI,CAACC,GAAG,CAACD,QAAQ;YACpB,OAAO,IAAI;QACb;QACA,MAAMV,OAAOP,aAAaO,IAAI,CAAC,IAAI;QACnCA,IAAI,CAACN,kBAAkB,CAACkB,MAAM,CAACF;QAC/B,OAAOV;IACT;IAEOW,IAAID,KAAQ,EAAW;QAC5B,OAAO,IAAI,CAAChB,kBAAkB,CAACiB,GAAG,CAACD;IACrC;IAEO,CAACf,iBAAgB,GAAgB;QACtC,OAAO,IAAI,CAACD,kBAAkB,CAACmB,MAAM;IACvC;IApCA;;;;;;GAMC,GACDC,YAAYC,WAAmB,CAAE;QAtCjCC,IAAAA,kBAAA,EAAA,IAAA,EAAgBC,QAAhB,KAAA;QAEAD,IAAAA,kBAAA,EAAA,IAAA,EAAStB,oBAAT,KAAA;QAqCE,IAAI,CAACA,kBAAkB,GAAGqB;QAC1B,IAAI,CAACE,IAAI,GAAG,IAAI,CAACvB,kBAAkB,CAACuB,IAAI;IAC1C;AA2BF;AArEED,IAAAA,kBAAA,EADWvB,cACGa,SAA6B,IAAIb,aAAa,IAAIS"}

package/lib-commonjs/utils/createCheckedItems.js

@@ -9,20 +9,8 @@ Object.defineProperty(exports, "createCheckedItems", {
     }
 });
 const _ImmutableMap = require("./ImmutableMap");
-function createCheckedItems(iterable) {
-    if (iterable === undefined) {
-        return _ImmutableMap.ImmutableMap.empty;
-    }
-    if (_ImmutableMap.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.ImmutableMap.dangerouslyCreate_unstable(internalMap);
-}
+const tuplifyCheckedItem = (value)=>Array.isArray(value) ? value : [
+        value,
+        true
+    ];
+const createCheckedItems = (iterable)=>_ImmutableMap.ImmutableMap.from(iterable, tuplifyCheckedItem);

package/lib-commonjs/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":["createCheckedItems","iterable","undefined","ImmutableMap","empty","isImmutableMap","internalMap","Map","item","Array","isArray","set","dangerouslyCreate_unstable"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAIgBA;;;eAAAA;;;8BAJa;AAItB,SAASA,mBAAmBC,QAAwE;IACzG,IAAIA,aAAaC,WAAW;QAC1B,OAAOC,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAID,0BAAAA,CAAaE,cAAc,CAAoCJ,WAAW;QAC5E,OAAOA;IACT;IACA,MAAMK,cAAc,IAAIC;IACxB,KAAK,MAAMC,QAAQP,SAAU;QAC3B,IAAIQ,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,OAAOL,0BAAAA,CAAaS,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":["createCheckedItems","tuplifyCheckedItem","value","Array","isArray","iterable","ImmutableMap","from"],"rangeMappings":";;;;;;;;;;;;;;;","mappings":";;;;+BAQaA;;;eAAAA;;;8BANgB;AAE7B,MAAMC,qBAAqB,CACzBC,QACyCC,MAAMC,OAAO,CAACF,SAASA,QAAQ;QAACA;QAAO;KAAK;AAEhF,MAAMF,qBAAqB,CAChCK,WACoDC,0BAAAA,CAAaC,IAAI,CAACF,UAAUJ"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluentui/react-tree",
-  "version": "9.7.6",
+  "version": "9.7.8",
   "description": "Tree component for Fluent UI React",
   "main": "lib-commonjs/index.js",
   "module": "lib/index.js",
@@ -35,11 +35,13 @@
   "dependencies": {
     "@fluentui/keyboard-keys": "^9.0.7",
     "@fluentui/react-aria": "^9.13.2",
-    "@fluentui/react-avatar": "^9.6.34",
+    "@fluentui/react-avatar": "^9.6.35",
     "@fluentui/react-button": "^9.3.87",
     "@fluentui/react-checkbox": "^9.2.33",
     "@fluentui/react-context-selector": "^9.1.65",
     "@fluentui/react-icons": "^2.0.245",
+    "@fluentui/react-motion-components-preview": "^0.1.1",
+    "@fluentui/react-motion": "^9.4.0",
     "@fluentui/react-radio": "^9.2.28",
     "@fluentui/react-shared-contexts": "^9.20.0",
     "@fluentui/react-tabster": "^9.22.3",

package/lib/utils/createOpenItems.js

@@ -1,10 +0,0 @@
-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

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

package/lib-commonjs/utils/createOpenItems.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createOpenItems", {
-    enumerable: true,
-    get: function() {
-        return createOpenItems;
-    }
-});
-const _ImmutableSet = require("./ImmutableSet");
-function createOpenItems(iterable) {
-    if (iterable === undefined) {
-        return _ImmutableSet.ImmutableSet.empty;
-    }
-    if (_ImmutableSet.ImmutableSet.isImmutableSet(iterable)) {
-        return iterable;
-    }
-    return _ImmutableSet.ImmutableSet.create(iterable);
-}

package/lib-commonjs/utils/createOpenItems.js.map

@@ -1 +0,0 @@
-{"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":["createOpenItems","iterable","undefined","ImmutableSet","empty","isImmutableSet","create"],"rangeMappings":";;;;;;;;;;;;;;;;;;;","mappings":";;;;+BAGgBA;;;eAAAA;;;8BAHa;AAGtB,SAASA,gBAAgBC,QAAkC;IAChE,IAAIA,aAAaC,WAAW;QAC1B,OAAOC,0BAAAA,CAAaC,KAAK;IAC3B;IACA,IAAID,0BAAAA,CAAaE,cAAc,CAAgBJ,WAAW;QACxD,OAAOA;IACT;IACA,OAAOE,0BAAAA,CAAaG,MAAM,CAACL;AAC7B"}